TBinaryFunctor

About

Generically, functor objects are instances of a class with member function Call defined. This member function allows the object to be used with the same syntax as a regular function call, and therefore its type can be used as template parameter when a generic function type is expected.

In the case of binary functor objects, this Call member function takes two parameters.

uses
  utils.functor;
  
type
 generic TBinaryFunctor<V, R> = class
 public
   function Call(AValue1, AValue2 : V) : R; abstract;
 end;

Example

uses
  utils.functor;
  
type
  TFunctor = {$IFDEF FPC}specialize{$ENDIF} TBinaryFunctor<Integer, Integer>
  public
    function Call(AValue1, AValue2 : Integer) : Integer; override;
    begin
      if AValue1 < AValue2 then
        Exit(-1)
      else if AValue1 > AValue2 then
        Exit(1)
      else
        Exit(0);
    end;
  end;
  
var
  functor : TFunctor;
  
begin
  functor := TFunctor.Create;
  if functor.Call(21, 5) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TUnsortableFunctor

It is a special compare functor that return 0 (zero) all times. Real values not used. This functor can be used for containers for unsortable values.

uses
  utils.functor;

type  
  TUnsortableFunctor = 
    class({$IFDEF FPC}specialize{$ENDIF} TBinaryFunctor<V, Integer>);

Example

uses
  container.arraylist, utils.functor;
  
type
  TObjectArray = {$IFDEF FPC}specialize{$ENDIF} TArrayList<TObject, TUnsortableFunctor>;
 
var
  arr : TObjectArray;
  
begin
  arr := TObjectArray.Create;
  
  FreeAndNil(arr);
end;

TDefaultCompareFunctor

It is a functor which return a negative value if AValue1 should be sorted before AValue2, a positive value if AValue1 should be sorted after AValue2, zero if AValue1 and AValue2 are equal.

uses
  utils.functor;
  
type
  generic TDefaultCompareFunctor<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TBinaryFunctor<V, Integer>)
  public
    function Call(AValue1, AValue2 : V) : Integer;
  end;

Example

uses
  utils.functor;
  
type
  TCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<Integer>
  public
    function Call(AValue1, AValue2 : Integer) : Integer; override;
    begin
      if AValue1 < AValue2 then
        Exit(-1)
      else if AValue1 > AValue2 then
        Exit(1)
      else
        Exit(0);
    end;
  end;
  
var
  functor : TCompareFunctor;
  
begin
  functor := TCompareFunctor.Create;
  if functor.Call(21, 5) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorByte

uses
  utils.functor;

type  
  TCompareFunctorByte = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<Byte>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorByte;
  
begin
  functor := TCompareFunctorByte.Create;
  if functor.Call(2, 12) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorShortInt

uses
  utils.functor;

type  
  TCompareFunctorShortInt = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<ShortInt>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorShortInt;
  
begin
  functor := TCompareFunctorShortInt.Create;
  if functor.Call(254, 1200) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorWord

uses
  utils.functor;

type  
  TCompareFunctorWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<Word>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorWord;
  
begin
  functor := TCompareFunctorWord.Create;
  if functor.Call(0, 54) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorSmallInt

uses
  utils.functor;

type  
  TCompareFunctorSmallInt = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<SmallInt>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorSmallInt;
  
begin
  functor := TCompareFunctorSmallInt.Create;
  if functor.Call(0, -54) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorInteger

uses
  utils.functor;

type  
  TCompareFunctorInteger = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<Integer>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorInteger;
  
begin
  functor := TCompareFunctorInteger.Create;
  if functor.Call(-5842, 25410) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorDWord

This functor available for FreePascal compiler only!

uses
  utils.functor;

type  
{$IFDEF FPC}
  TCompareFunctorDWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<DWord>);
{$ENDIF}

Example

uses
  utils.functor;

var
  functor : TCompareFunctorDWord;
  
begin
  functor := TCompareFunctorDWord.Create;
  if functor.Call(452, 5780) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorCardinal

uses
  utils.functor;

type  
  TCompareFunctorCardinal = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<Cardinal>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorCardinal;
  
begin
  functor := TCompareFunctorCardinal.Create;
  if functor.Call(5842, 25410) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorLongWord

uses
  utils.functor;

type  
  TCompareFunctorLongWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<LongWord>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorLongWord;
  
begin
  functor := TCompareFunctorLongWord.Create;
  if functor.Call(12544, 25410) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorLongInt

uses
  utils.functor;

type  
  TCompareFunctorLongInt = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<LongInt>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorLongInt;
  
begin
  functor := TCompareFunctorLongInt.Create;
  if functor.Call(-5842, 0) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorQWord

This functor available for FreePascal compiler only!

uses
  utils.functor;

type  
{$IFDEF FPC}
  TCompareFunctorQWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<QWord>);
{$ENDIF}

Example

uses
  utils.functor;

var
  functor : TCompareFunctorQWord;
  
begin
  functor := TCompareFunctorQWord.Create;
  if functor.Call(452, 5780) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorInt64

uses
  utils.functor;

type  
  TCompareFunctorInt64 = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<Int64>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorInt64;
  
begin
  functor := TCompareFunctorInt64.Create;
  if functor.Call(210, 541) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorSingle

uses
  utils.functor;

type  
  TCompareFunctorSingle = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<Single>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorSingle;
  
begin
  functor := TCompareFunctorSingle.Create;
  if functor.Call(0.21, 2.12) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorReal

uses
  utils.functor;

type  
  TCompareFunctorReal = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<Real>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorReal;
  
begin
  functor := TCompareFunctorReal.Create;
  if functor.Call(54.21, 10.12) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorDouble

uses
  utils.functor;

type  
  TCompareFunctorDouble = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<Double>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorDouble;
  
begin
  functor := TCompareFunctorDouble.Create;
  if functor.Call(1.99, -2.54) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorExtended

uses
  utils.functor;

type  
  TCompareFunctorExtended = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<Extended>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorExtended;
  
begin
  functor := TCompareFunctorExtended.Create;
  if functor.Call(1.499, -12.54) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorCurrency

uses
  utils.functor;

type  
  TCompareFunctorCurrency = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<Currency>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorCurrency;
  
begin
  functor := TCompareFunctorCurrency.Create;
  if functor.Call(1232.499, 1622.54) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorBoolean

uses
  utils.functor;

type  
  TCompareFunctorBoolean = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<Boolean>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorBoolean;
  
begin
  functor := TCompareFunctorBoolean.Create;
  if functor.Call(True, False) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorChar

uses
  utils.functor;

type  
  TCompareFunctorChar = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<Char>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorChar;
  
begin
  functor := TCompareFunctorChar.Create;
  if functor.Call('a', 'z') < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorWideChar

uses
  utils.functor;

type  
  TCompareFunctorWideChar = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<WideChar>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorWideChar;
  
begin
  functor := TCompareFunctorWideChar.Create;
  if functor.Call('F', 'J') < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorAnsiString

uses
  utils.functor;

type  
  TCompareFunctorAnsiString = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<AnsiString>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorAnsiString;
  
begin
  functor := TCompareFunctorAnsiString.Create;
  if functor.Call('test', 'string') < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorString

uses
  utils.functor;

type  
  TCompareFunctorString = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<String>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorString;
  
begin
  functor := TCompareFunctorString.Create;
  if functor.Call('some', 'value') < 0 then
    ;
  
  FreeAndNil(functor);
end;

TCompareFunctorWideString

uses
  utils.functor;

type  
  TCompareFunctorWideString = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultCompareFunctor<WideString>);

Example

uses
  utils.functor;

var
  functor : TCompareFunctorWideString;
  
begin
  functor := TCompareFunctorWideString.Create;
  if functor.Call('some', 'another value') < 0 then
    ;
  
  FreeAndNil(functor);
end;

TDefaultLessFunctor

Return True if AValue1 < AValue2.

uses
  utils.functor;
  
type
  generic TDefaultLessFunctor<V> =
    class ({$IFDEF FPC}specialize{$ENDIF} TBinaryFunctor<V, Boolean>);

TLessFunctorByte

uses
  utils.functor;

type  
  TLessFunctorByte = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<Byte>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorByte;
  
begin
  functor := TLessFunctorByte.Create;
  if functor.Call(2, 12) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorShortInt

uses
  utils.functor;

type  
  TLessFunctorShortInt = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<ShortInt>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorShortInt;
  
begin
  functor := TLessFunctorShortInt.Create;
  if functor.Call(24, -12) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorWord

uses
  utils.functor;

type  
  TLessFunctorWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<Word>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorWord;
  
begin
  functor := TLessFunctorWord.Create;
  if functor.Call(24, 120) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorSmallInt

uses
  utils.functor;

type  
  TLessFunctorSmallInt = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<SmallInt>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorSmallInt;
  
begin
  functor := TLessFunctorSmallInt.Create;
  if functor.Call(24, 120) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorInteger

uses
  utils.functor;

type  
  TLessFunctorInteger = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<Integer>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorInteger;
  
begin
  functor := TLessFunctorInteger.Create;
  if functor.Call(24, -54) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorDWord

This functor available for FreePascal compiler only!

uses
  utils.functor;

type  
{$IFDEF FPC}
  TLessFunctorDWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<DWord>);
{$ENDIF}

Example

uses
  utils.functor;

var
  functor : TLessFunctorDWord;
  
begin
  functor := TLessFunctorDWord.Create;
  if functor.Call(204, 54) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorCardinal

uses
  utils.functor;

type  
  TLessFunctorCardinal = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<Cardinal>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorCardinal;
  
begin
  functor := TLessFunctorCardinal.Create;
  if functor.Call(4, 81) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorLongWord

uses
  utils.functor;

type  
  TLessFunctorLongWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<LongWord>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorLongWord;
  
begin
  functor := TLessFunctorLongWord.Create;
  if functor.Call(412, 812) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorLongInt

uses
  utils.functor;

type  
  TLessFunctorLongInt = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<LongInt>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorLongInt;
  
begin
  functor := TLessFunctorLongInt.Create;
  if functor.Call(-5, 2) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorQWord

This functor available for FreePascal compiler only!

uses
  utils.functor;

type  
{$IFDEF FPC}
  TLessFunctorQWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<QWord>);
{$ENDIF}

Example

uses
  utils.functor;

var
  functor : TLessFunctorQWord;
  
begin
  functor := TLessFunctorQWord.Create;
  if functor.Call(2042, 5214) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorInt64

uses
  utils.functor;

type  
  TLessFunctorInt64 = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<Int64>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorInt64;
  
begin
  functor := TLessFunctorInt64.Create;
  if functor.Call(-12255, 2131221) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorSingle

uses
  utils.functor;

type  
  TLessFunctorSingle = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<Single>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorSingle;
  
begin
  functor := TLessFunctorSingle.Create;
  if functor.Call(0.254, 4.325) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorReal

uses
  utils.functor;

type  
  TLessFunctorReal = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<Real>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorReal;
  
begin
  functor := TLessFunctorReal.Create;
  if functor.Call(0.2254, 41.325) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorDouble

uses
  utils.functor;

type  
  TLessFunctorDouble = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<Double>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorDouble;
  
begin
  functor := TLessFunctorDouble.Create;
  if functor.Call(25.36, 11.25410) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorExtended

uses
  utils.functor;

type  
  TLessFunctorExtended = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<Extended>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorExtended;
  
begin
  functor := TLessFunctorExtended.Create;
  if functor.Call(252.36, 111.20) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorCurrency

uses
  utils.functor;

type  
  TLessFunctorCurrency = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<Currency>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorCurrency;
  
begin
  functor := TLessFunctorCurrency.Create;
  if functor.Call(123.36, 541.12) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorBoolean

uses
  utils.functor;

type  
  TLessFunctorBoolean = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<Boolean>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorBoolean;
  
begin
  functor := TLessFunctorBoolean.Create;
  if functor.Call(False, False) then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorChar

uses
  utils.functor;

type  
  TLessFunctorChar = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<Char>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorChar;
  
begin
  functor := TLessFunctorChar.Create;
  if functor.Call('f', 'e') then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorWideChar

uses
  utils.functor;

type  
  TLessFunctorWideChar = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<WideChar>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorWideChar;
  
begin
  functor := TLessFunctorWideChar.Create;
  if functor.Call('r', 'w') then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorAnsiString

uses
  utils.functor;

type  
  TLessFunctorAnsiString = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<AnsiString>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorAnsiString;
  
begin
  functor := TLessFunctorAnsiString.Create;
  if functor.Call('string', 'another one') then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorString

uses
  utils.functor;

type  
  TLessFunctorString = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<String>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorString;
  
begin
  functor := TLessFunctorString.Create;
  if functor.Call('string', 'another one') then
    ;
  
  FreeAndNil(functor);
end;

TLessFunctorWideString

uses
  utils.functor;

type  
  TLessFunctorWideString = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultLessFunctor<WideString>);

Example

uses
  utils.functor;

var
  functor : TLessFunctorWideString;
  
begin
  functor := TLessFunctorWideString.Create;
  if functor.Call('value', 'different value') then
    ;
  
  FreeAndNil(functor);
end;

TDefaultGreaterFunctor

Return True if AValue1 > AValue2.

uses
  utils.functor;
  
type
  generic TDefaultGreaterFunctor<V> =
    class ({$IFDEF FPC}specialize{$ENDIF} TBinaryFunctor<V, Boolean>);

TGreaterFunctorByte

uses
  utils.functor;

type  
  TGreaterFunctorByte = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<Byte>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorByte;
  
begin
  functor := TGreaterFunctorByte.Create;
  if functor.Call(2, 12) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorShortInt

uses
  utils.functor;

type  
  TGreaterFunctorShortInt = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<ShortInt>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorShortInt;
  
begin
  functor := TGreaterFunctorShortInt.Create;
  if functor.Call(24, -12) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorWord

uses
  utils.functor;

type  
  TGreaterFunctorWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<Word>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorWord;
  
begin
  functor := TGreaterFunctorWord.Create;
  if functor.Call(24, 120) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorSmallInt

uses
  utils.functor;

type  
  TGreaterFunctorSmallInt = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<SmallInt>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorSmallInt;
  
begin
  functor := TGreaterFunctorSmallInt.Create;
  if functor.Call(24, 120) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorInteger

uses
  utils.functor;

type  
  TGreaterFunctorInteger = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<Integer>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorInteger;
  
begin
  functor := TGreaterFunctorInteger.Create;
  if functor.Call(24, -54) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorDWord

This functor available for FreePascal compiler only!

uses
  utils.functor;

type  
{$IFDEF FPC}
  TGreaterFunctorDWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<DWord>);
{$ENDIF}

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorDWord;
  
begin
  functor := TGreaterFunctorDWord.Create;
  if functor.Call(204, 54) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorCardinal

uses
  utils.functor;

type  
  TGreaterFunctorCardinal = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<Cardinal>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorCardinal;
  
begin
  functor := TGreaterFunctorCardinal.Create;
  if functor.Call(4, 81) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorLongWord

uses
  utils.functor;

type  
  TGreaterFunctorLongWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<LongWord>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorLongWord;
  
begin
  functor := TGreaterFunctorLongWord.Create;
  if functor.Call(412, 812) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorLongInt

uses
  utils.functor;

type  
  TGreaterFunctorLongInt = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<LongInt>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorLongInt;
  
begin
  functor := TGreaterFunctorLongInt.Create;
  if functor.Call(-5, 2) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorQWord

This functor available for FreePascal compiler only!

uses
  utils.functor;

type  
{$IFDEF FPC}
  TGreaterFunctorQWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<QWord>);
{$ENDIF}

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorQWord;
  
begin
  functor := TGreaterFunctorQWord.Create;
  if functor.Call(2042, 5214) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorInt64

uses
  utils.functor;

type  
  TGreaterFunctorInt64 = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<Int64>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorInt64;
  
begin
  functor := TGreaterFunctorInt64.Create;
  if functor.Call(-12255, 2131221) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorSingle

uses
  utils.functor;

type  
  TGreaterFunctorSingle = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<Single>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorSingle;
  
begin
  functor := TGreaterFunctorSingle.Create;
  if functor.Call(0.254, 4.325) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorReal

uses
  utils.functor;

type  
  TGreaterFunctorReal = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<Real>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorReal;
  
begin
  functor := TGreaterFunctorReal.Create;
  if functor.Call(0.2254, 41.325) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorDouble

uses
  utils.functor;

type  
  TGreaterFunctorDouble = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<Double>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorDouble;
  
begin
  functor := TGreaterFunctorDouble.Create;
  if functor.Call(25.36, 11.25410) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorExtended

uses
  utils.functor;

type  
  TGreaterFunctorExtended = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<Extended>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorExtended;
  
begin
  functor := TGreaterFunctorExtended.Create;
  if functor.Call(252.36, 111.20) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorCurrency

uses
  utils.functor;

type  
  TGreaterFunctorCurrency = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<Currency>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorCurrency;
  
begin
  functor := TGreaterFunctorCurrency.Create;
  if functor.Call(123.36, 541.12) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorBoolean

uses
  utils.functor;

type  
  TGreaterFunctorBoolean = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<Boolean>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorBoolean;
  
begin
  functor := TGreaterFunctorBoolean.Create;
  if functor.Call(False, False) then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorChar

uses
  utils.functor;

type  
  TGreaterFunctorChar = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<Char>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorChar;
  
begin
  functor := TGreaterFunctorChar.Create;
  if functor.Call('f', 'e') then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorWideChar

uses
  utils.functor;

type  
  TGreaterFunctorWideChar = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<WideChar>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorWideChar;
  
begin
  functor := TGreaterFunctorWideChar.Create;
  if functor.Call('r', 'w') then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorAnsiString

uses
  utils.functor;

type  
  TGreaterFunctorAnsiString = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<AnsiString>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorAnsiString;
  
begin
  functor := TGreaterFunctorAnsiString.Create;
  if functor.Call('string', 'another one') then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorString

uses
  utils.functor;

type  
  TGreaterFunctorString = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<String>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorString;
  
begin
  functor := TGreaterFunctorString.Create;
  if functor.Call('string', 'another one') then
    ;
  
  FreeAndNil(functor);
end;

TGreaterFunctorWideString

uses
  utils.functor;

type  
  TGreaterFunctorWideString = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultGreaterFunctor<WideString>);

Example

uses
  utils.functor;

var
  functor : TGreaterFunctorWideString;
  
begin
  functor := TGreaterFunctorWideString.Create;
  if functor.Call('value', 'different value') then
    ;
  
  FreeAndNil(functor);
end;

TDefaultEqualFunctor

Return True if AValue1 = AValue2.

uses
  utils.functor;
  
type
  generic TDefaultEqualFunctor<V> =
    class ({$IFDEF FPC}specialize{$ENDIF} TBinaryFunctor<V, Boolean>);

TEqualFunctorByte

uses
  utils.functor;

type  
  TEqualFunctorByte = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<Byte>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorByte;
  
begin
  functor := TEqualFunctorByte.Create;
  if functor.Call(2, 12) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorShortInt

uses
  utils.functor;

type  
  TEqualFunctorShortInt = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<ShortInt>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorShortInt;
  
begin
  functor := TEqualFunctorShortInt.Create;
  if functor.Call(24, -12) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorWord

uses
  utils.functor;

type  
  TEqualFunctorWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<Word>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorWord;
  
begin
  functor := TEqualFunctorWord.Create;
  if functor.Call(24, 120) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorSmallInt

uses
  utils.functor;

type  
  TEqualFunctorSmallInt = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<SmallInt>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorSmallInt;
  
begin
  functor := TEqualFunctorSmallInt.Create;
  if functor.Call(24, 120) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorInteger

uses
  utils.functor;

type  
  TEqualFunctorInteger = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<Integer>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorInteger;
  
begin
  functor := TEqualFunctorInteger.Create;
  if functor.Call(24, -54) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorDWord

This functor available for FreePascal compiler only!

uses
  utils.functor;

type  
{$IFDEF FPC}
  TEqualFunctorDWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<DWord>);
{$ENDIF}

Example

uses
  utils.functor;

var
  functor : TEqualFunctorDWord;
  
begin
  functor := TEqualFunctorDWord.Create;
  if functor.Call(204, 54) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorCardinal

uses
  utils.functor;

type  
  TEqualFunctorCardinal = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<Cardinal>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorCardinal;
  
begin
  functor := TEqualFunctorCardinal.Create;
  if functor.Call(4, 81) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorLongWord

uses
  utils.functor;

type  
  TEqualFunctorLongWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<LongWord>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorLongWord;
  
begin
  functor := TEqualFunctorLongWord.Create;
  if functor.Call(412, 812) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorLongInt

uses
  utils.functor;

type  
  TEqualFunctorLongInt = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<LongInt>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorLongInt;
  
begin
  functor := TEqualFunctorLongInt.Create;
  if functor.Call(-5, 2) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorQWord

This functor available for FreePascal compiler only!

uses
  utils.functor;

type  
{$IFDEF FPC}
  TEqualFunctorQWord = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<QWord>);
{$ENDIF}

Example

uses
  utils.functor;

var
  functor : TEqualFunctorQWord;
  
begin
  functor := TEqualFunctorQWord.Create;
  if functor.Call(2042, 5214) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorInt64

uses
  utils.functor;

type  
  TEqualFunctorInt64 = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<Int64>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorInt64;
  
begin
  functor := TEqualFunctorInt64.Create;
  if functor.Call(-12255, 2131221) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorSingle

uses
  utils.functor;

type  
  TEqualFunctorSingle = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<Single>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorSingle;
  
begin
  functor := TEqualFunctorSingle.Create;
  if functor.Call(0.254, 4.325) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorReal

uses
  utils.functor;

type  
  TEqualFunctorReal = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<Real>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorReal;
  
begin
  functor := TEqualFunctorReal.Create;
  if functor.Call(0.2254, 41.325) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorDouble

uses
  utils.functor;

type  
  TEqualFunctorDouble = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<Double>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorDouble;
  
begin
  functor := TEqualFunctorDouble.Create;
  if functor.Call(25.36, 11.25410) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorExtended

uses
  utils.functor;

type  
  TEqualFunctorExtended = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<Extended>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorExtended;
  
begin
  functor := TEqualFunctorExtended.Create;
  if functor.Call(252.36, 111.20) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorCurrency

uses
  utils.functor;

type  
  TEqualFunctorCurrency = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<Currency>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorCurrency;
  
begin
  functor := TEqualFunctorCurrency.Create;
  if functor.Call(123.36, 541.12) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorBoolean

uses
  utils.functor;

type  
  TEqualFunctorBoolean = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<Boolean>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorBoolean;
  
begin
  functor := TEqualFunctorBoolean.Create;
  if functor.Call(False, False) then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorChar

uses
  utils.functor;

type  
  TEqualFunctorChar = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<Char>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorChar;
  
begin
  functor := TEqualFunctorChar.Create;
  if functor.Call('f', 'e') then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorWideChar

uses
  utils.functor;

type  
  TEqualFunctorWideChar = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<WideChar>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorWideChar;
  
begin
  functor := TEqualFunctorWideChar.Create;
  if functor.Call('r', 'w') then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorAnsiString

uses
  utils.functor;

type  
  TEqualFunctorAnsiString = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<AnsiString>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorAnsiString;
  
begin
  functor := TEqualFunctorAnsiString.Create;
  if functor.Call('string', 'another one') then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorString

uses
  utils.functor;

type  
  TEqualFunctorString = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<String>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorString;
  
begin
  functor := TEqualFunctorString.Create;
  if functor.Call('string', 'another one') then
    ;
  
  FreeAndNil(functor);
end;

TEqualFunctorWideString

uses
  utils.functor;

type  
  TEqualFunctorWideString = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultEqualFunctor<WideString>);

Example

uses
  utils.functor;

var
  functor : TEqualFunctorWideString;
  
begin
  functor := TEqualFunctorWideString.Create;
  if functor.Call('value', 'different value') then
    ;
  
  FreeAndNil(functor);
end;

TDefaultPairKeyCompareFunctor

Return a negative value if pair 1 key should be sorted before pair 2 key, a positive value if pair 1 key should be sorted after pair 2 key, zero if pair 1 key and pair 2 key are equal.

uses
  utils.functor, utils.pair;
  
uses
  generic TDefaultPairKeyCompareFunctor<K, V> =
    class({$IFDEF FPC}specialize{$ENDIF} TBinaryFunctor
    <{$IFDEF FPC}specialize{$ENDIF} TPair<K, V>, Integer>)

TPairKeyCompareFunctorByte

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorByte<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<Byte, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<Byte, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorByte<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(1, 1);
  pair2 := TPairValue.Create(9, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorShortInt

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorShortInt<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<ShortInt, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<ShortInt, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorShortInt<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(10, 1);
  pair2 := TPairValue.Create(-29, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorWord

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorWord<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<Word, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<Word, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorWord<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(102, 1);
  pair2 := TPairValue.Create(25, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorSmallInt

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorSmallInt<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<SmallInt, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<SmallInt, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorSmallInt<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(-102, 1);
  pair2 := TPairValue.Create(255, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorInteger

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorInteger<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<Integer, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<Integer, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorInteger<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(1202, 1);
  pair2 := TPairValue.Create(2535, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorDWord

This functor available for FreePascal compiler only!

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorDWord<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<Integer, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<DWord, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorDWord<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(54, 1);
  pair2 := TPairValue.Create(84, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorCardinal

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorCardinal<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<Cardinal, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<Cardinal, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorCardinal<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(254, 1);
  pair2 := TPairValue.Create(834, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorLongWord

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorLongWord<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<LongWord, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<LongWord, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorLongWord<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(2534, 1);
  pair2 := TPairValue.Create(8342, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorLongInt

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorLongInt<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<LongInt, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<LongInt, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorLongInt<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(22534, 1);
  pair2 := TPairValue.Create(-8342, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorQWord

This functor available for FreePascal compiler only!

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorQWord<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<QWord, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<QWord, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorQWord<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(9654, 1);
  pair2 := TPairValue.Create(250, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorInt64

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorInt64<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<Int64, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<Int64, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorInt64<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(-9654, 1);
  pair2 := TPairValue.Create(-5250, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorSingle

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorSingle<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<Single, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<Single, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorSingle<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(2.2541, 1);
  pair2 := TPairValue.Create(-2.3256, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorReal

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorReal<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<Real, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<Real, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorReal<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(22.1, 1);
  pair2 := TPairValue.Create(51.547, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorDouble

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorDouble<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<Double, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<Double, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorDouble<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(232.11, 1);
  pair2 := TPairValue.Create(531.5247, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorExtended

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorExtended<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<Extended, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<Extended, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorExtended<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(2232.11, 1);
  pair2 := TPairValue.Create(5321.5247, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorCurrency

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorCurrency<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<Currency, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<Currency, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorCurrency<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(22.11, 1);
  pair2 := TPairValue.Create(51.47, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorBoolean

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorBoolean<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<Boolean, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<Boolean, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorBoolean<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create(False, 1);
  pair2 := TPairValue.Create(True, 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorChar

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorChar<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<Char, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<Char, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorChar<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create('l', 1);
  pair2 := TPairValue.Create('t', 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorWideChar

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorWideChar<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<WideChar, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<WideChar, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorWideChar<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create('a', 1);
  pair2 := TPairValue.Create('a', 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorAnsiString

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorAnsiString<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<AnsiString, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<AnsiString, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorAnsiString<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create('value', 1);
  pair2 := TPairValue.Create('value 2', 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorString

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorString<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<String, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<String, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorString<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create('some value', 1);
  pair2 := TPairValue.Create('another value', 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TPairKeyCompareFunctorWideString

uses
  utils.functor, utils.pair;
  
type
  generic TPairKeyCompareFunctorWideString<V> = 
    class({$IFDEF FPC}specialize{$ENDIF} TDefaultPairKeyCompareFunctor<WideString, 
    V>);

Example

uses
  utils.functor, utils.pair;

type
  TPairValue = {$IFDEF FPC}specialize{$ENDIF} TPair<WideString, Integer>;
  TPairCompareFunctor = {$IFDEF FPC}specialize{$ENDIF} TPairKeyCompareFunctorWideString<Integer>;

var
  functor : TPairCompareFunctor;
  pair1, pair2 : TPairValue;
  
begin
  functor := TPairCompareFunctor.Create;
  pair1 := TPairValue.Create('some value', 1);
  pair2 := TPairValue.Create('another value', 0);
  
  if functor.Call(pair1, pair2) < 0 then
    ;
  
  FreeAndNil(functor);
end;

TBinaryFunctor

Table of contents

About

Example

TUnsortableFunctor

Example

TDefaultCompareFunctor

Example

TCompareFunctorByte

Example

TCompareFunctorShortInt

Example

TCompareFunctorWord

Example

TCompareFunctorSmallInt

Example

TCompareFunctorInteger

Example

TCompareFunctorDWord

Example

TCompareFunctorCardinal

Example

TCompareFunctorLongWord

Example

TCompareFunctorLongInt

Example

TCompareFunctorQWord

Example

TCompareFunctorInt64

Example

TCompareFunctorSingle

Example

TCompareFunctorReal

Example

TCompareFunctorDouble

Example

TCompareFunctorExtended

Example

TCompareFunctorCurrency

Example

TCompareFunctorBoolean

Example

TCompareFunctorChar

Example

TCompareFunctorWideChar

Example

TCompareFunctorAnsiString

Example

TCompareFunctorString

Example

TCompareFunctorWideString

Example

TDefaultLessFunctor

TLessFunctorByte

Example

TLessFunctorShortInt

Example

TLessFunctorWord

Example

TLessFunctorSmallInt

Example

TLessFunctorInteger

Example

TLessFunctorDWord

Example

TLessFunctorCardinal

Example

TLessFunctorLongWord

Example

TLessFunctorLongInt

Example

TLessFunctorQWord

Example

TLessFunctorInt64

Example

TLessFunctorSingle

Example

TLessFunctorReal

Example

TLessFunctorDouble