unit uutlLinq;

{$mode objfpc}{$H+}
{$IFDEF UTL_NESTED_PROCVARS}
  {$modeswitch nestedprocvars}
{$ENDIF}

interface

{$IFDEF UTL_ENUMERATORS}
uses
  Classes, SysUtils,
  uutlTypes, uutlInterfaces, uutlComparer, uutlFilter;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  generic function utlCount<T>(
    constref aEnumerator: specialize IutlEnumerator<T>): Integer; inline;

  generic function utlAny<T>(
    constref aEnumerator: specialize IutlEnumerator<T>): Boolean; inline;

  generic function utlToArray<T>(
    constref aEnumerator: specialize IutlEnumerator<T>): specialize TutlArray<T>; inline;

  generic function utlContains<T>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aElement: T): Boolean; inline; overload;

  generic function utlContains<T>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aElement: T;
    constref aComparer: specialize IutlEqualityComparer<T>): Boolean; inline; overload;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  generic function utlSkip<T>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    const aSkip: Integer): specialize IutlEnumerator<T>; inline;

  generic function utlTake<T>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    const aTake: Integer): specialize IutlEnumerator<T>; inline;

  generic function utlConcat<T>(
    constref aEnumerator1, aEnumerator2: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlConcat<T>(
    constref aEnumerators: specialize TutlArray<specialize IutlEnumerator<T>>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlReverse<T>(
    constref aEnumerator: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>; inline;

  {$IFDEF UTL_ADVANCED_ENUMERATORS}
  generic function utlSort<T>(
    constref aEnumerator: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlSort<T>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aComparer: specialize IutlComparer<T>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlWhere<T>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aFilter: specialize IutlFilter<T>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlWhere<T>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aFilter: specialize TutlFilterEvent<T>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlWhere<T>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aFilter: specialize TutlFilterEventO<T>): specialize IutlEnumerator<T>; inline; overload;

  {$IFDEF UTL_NESTED_PROCVARS}
  generic function utlWhere<T>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aFilter: specialize TutlFilterEventN<T>): specialize IutlEnumerator<T>; inline; overload;
  {$ENDIF}

  generic function utlDistinct<T>(
    constref aEnumerator: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlDistinct<T>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aComparer: specialize IutlComparer<T>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlIntersect<T>(
    constref aEnumerator1: specialize IutlEnumerator<T>;
    constref aEnumerator2: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlIntersect<T>(
    constref aEnumerator1: specialize IutlEnumerator<T>;
    constref aEnumerator2: specialize IutlEnumerator<T>;
    constref aComparer: specialize IutlComparer<T>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlUnion<T>(
    constref aEnumerator1: specialize IutlEnumerator<T>;
    constref aEnumerator2: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlUnion<T>(
    constref aEnumerator1: specialize IutlEnumerator<T>;
    constref aEnumerator2: specialize IutlEnumerator<T>;
    constref aComparer: specialize IutlComparer<T>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlWithout<T>(
    constref aEnumerator1: specialize IutlEnumerator<T>;
    constref aEnumerator2: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlWithout<T>(
    constref aEnumerator1: specialize IutlEnumerator<T>;
    constref aEnumerator2: specialize IutlEnumerator<T>;
    constref aComparer: specialize IutlComparer<T>): specialize IutlEnumerator<T>; inline; overload;

  generic function utlSelect<T, S>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aSelector: specialize IutlSelector<T, S>): specialize IutlEnumerator<S>; inline; overload;

  generic function utlSelect<T, S>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aSelector: specialize TutlSelectEvent<T, S>): specialize IutlEnumerator<S>; inline; overload;

  generic function utlSelect<T, S>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aSelector: specialize TutlSelectEventO<T, S>): specialize IutlEnumerator<S>; inline; overload;

  {$IFDEF UTL_NESTED_PROCVARS}
  generic function utlSelect<T, S>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aSelector: specialize TutlSelectEventN<T, S>): specialize IutlEnumerator<S>; inline; overload;
  {$ENDIF}

  generic function utlSelectMany<T, S>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aSelector: specialize IutlSelector<T, specialize IutlEnumerator<S>>): specialize IutlEnumerator<S>; inline; overload;

  generic function utlSelectMany<T, S>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aSelector: specialize TutlSelectEvent<T, specialize IutlEnumerator<S>>): specialize IutlEnumerator<S>; inline; overload;

  generic function utlSelectMany<T, S>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aSelector: specialize TutlSelectEventO<T, specialize IutlEnumerator<S>>): specialize IutlEnumerator<S>; inline; overload;

  {$IFDEF UTL_NESTED_PROCVARS}
  generic function utlSelectMany<T, S>(
    constref aEnumerator: specialize IutlEnumerator<T>;
    constref aSelector: specialize TutlSelectEventN<T, specialize IutlEnumerator<S>>): specialize IutlEnumerator<S>; inline; overload;
  {$ENDIF}

  generic function utlZip<T, S>(
    constref aEnumerator1: specialize IutlEnumerator<T>;
    constref aEnumerator2: specialize IutlEnumerator<S>): specialize IutlEnumerator<specialize TutlPair<T, S>>;
  {$ENDIF}
{$ENDIF}

implementation

{$IFDEF UTL_ENUMERATORS}
uses
  uutlEnumerator;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//utlLinq///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlCount<T>(
  constref aEnumerator: specialize IutlEnumerator<T>): Integer;
begin
  result := aEnumerator.Count;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlAny<T>(
  constref aEnumerator: specialize IutlEnumerator<T>): Boolean;
begin
  result := aEnumerator.Any;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlToArray<T>(
  constref aEnumerator: specialize IutlEnumerator<T>): specialize TutlArray<T>;
begin
  result := aEnumerator.ToArray;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlContains<T>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aElement: T): Boolean;
begin
  result := aEnumerator.Contains(aElement, specialize TutlEqualityComparer<T>.Create);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlContains<T>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aElement: T;
  constref aComparer: specialize IutlEqualityComparer<T>): Boolean;
begin
  result := aEnumerator.Contains(aElement, aComparer);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlSkip<T>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  const aSkip: Integer): specialize IutlEnumerator<T>;
begin
  result := aEnumerator.Skip(aSkip);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlTake<T>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  const aTake: Integer): specialize IutlEnumerator<T>;
begin
  result := aEnumerator.Take(aTake);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlConcat<T>(
  constref aEnumerator1, aEnumerator2: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>;
type
  TConcatEnumerator = specialize TutlConcatEnumerator<T>;
begin
  result := TConcatEnumerator.Create(TConcatEnumerator.TEnumerators.Create(aEnumerator1, aEnumerator2));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlConcat<T>(
  constref aEnumerators: specialize TutlArray<specialize IutlEnumerator<T>>): specialize IutlEnumerator<T>;
type
  TConcatEnumerator = specialize TutlConcatEnumerator<T>;
begin
  result := TConcatEnumerator.Create(aEnumerators);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlReverse<T>(
  constref aEnumerator: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator.Reverse;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_ADVANCED_ENUMERATORS}
generic function utlSort<T>(
  constref aEnumerator: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator.Sort(specialize TutlComparer<T>.Create);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlSort<T>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aComparer: specialize IutlComparer<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator.Sort(aComparer);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlWhere<T>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aFilter: specialize IutlFilter<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator.Where(aFilter);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlWhere<T>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aFilter: specialize TutlFilterEvent<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator.Where(specialize TutlCallbackFilter<T>.Create(aFilter));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlWhere<T>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aFilter: specialize TutlFilterEventO<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator.Where(specialize TutlCallbackFilter<T>.Create(aFilter));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_NESTED_PROCVARS}
generic function utlWhere<T>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aFilter: specialize TutlFilterEventN<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator.Where(specialize TutlCallbackFilter<T>.Create(aFilter));
end;
{$ENDIF}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlDistinct<T>(
  constref aEnumerator: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator.Distinct(specialize TutlComparer<T>.Create);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlDistinct<T>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aComparer: specialize IutlComparer<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator.Distinct(aComparer);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlIntersect<T>(
  constref aEnumerator1: specialize IutlEnumerator<T>;
  constref aEnumerator2: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator1.Intersect(aEnumerator2, specialize TutlComparer<T>.Create);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlIntersect<T>(
  constref aEnumerator1: specialize IutlEnumerator<T>;
  constref aEnumerator2: specialize IutlEnumerator<T>;
  constref aComparer: specialize IutlComparer<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator1.Intersect(aEnumerator2, aComparer);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlUnion<T>(
  constref aEnumerator1: specialize IutlEnumerator<T>;
  constref aEnumerator2: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator1.Union(aEnumerator2, specialize TutlComparer<T>.Create);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlUnion<T>(
  constref aEnumerator1: specialize IutlEnumerator<T>;
  constref aEnumerator2: specialize IutlEnumerator<T>;
  constref aComparer: specialize IutlComparer<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator1.Union(aEnumerator2, aComparer);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlWithout<T>(
  constref aEnumerator1: specialize IutlEnumerator<T>;
  constref aEnumerator2: specialize IutlEnumerator<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator1.Without(aEnumerator2, specialize TutlComparer<T>.Create);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlWithout<T>(
  constref aEnumerator1: specialize IutlEnumerator<T>;
  constref aEnumerator2: specialize IutlEnumerator<T>;
  constref aComparer: specialize IutlComparer<T>): specialize IutlEnumerator<T>;
begin
  result := aEnumerator1.Without(aEnumerator2, aComparer);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlSelect<T, S>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aSelector: specialize IutlSelector<T, S>): specialize IutlEnumerator<S>;
begin
  result := specialize TutlSelectEnumerator<T, S>.Create(aEnumerator, aSelector);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlSelect<T, S>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aSelector: specialize TutlSelectEvent<T, S>): specialize IutlEnumerator<S>;
begin
  result := specialize TutlSelectEnumerator<T, S>.Create(aEnumerator, specialize TutlCallbackSelector<T, S>.Create(aSelector));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlSelect<T, S>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aSelector: specialize TutlSelectEventO<T, S>): specialize IutlEnumerator<S>;
begin
  result := specialize TutlSelectEnumerator<T, S>.Create(aEnumerator, specialize TutlCallbackSelector<T, S>.Create(aSelector));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_NESTED_PROCVARS}
generic function utlSelect<T, S>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aSelector: specialize TutlSelectEventN<T, S>): specialize IutlEnumerator<S>;
begin
  result := specialize TutlSelectEnumerator<T, S>.Create(aEnumerator, specialize TutlCallbackSelector<T, S>.Create(aSelector));
end;
{$ENDIF}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlSelectMany<T, S>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aSelector: specialize IutlSelector<T, specialize IutlEnumerator<S>>): specialize IutlEnumerator<S>;
begin
  result := specialize TutlSelectManyEnumerator<T, S>.Create(aEnumerator, aSelector);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlSelectMany<T, S>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aSelector: specialize TutlSelectEvent<T, specialize IutlEnumerator<S>>): specialize IutlEnumerator<S>;
begin
  result := specialize TutlSelectManyEnumerator<T, S>.Create(aEnumerator, specialize TutlCallbackSelector<T, specialize IutlEnumerator<S>>.Create(aSelector));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlSelectMany<T, S>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aSelector: specialize TutlSelectEventO<T, specialize IutlEnumerator<S>>): specialize IutlEnumerator<S>;
begin
  result := specialize TutlSelectManyEnumerator<T, S>.Create(aEnumerator, specialize TutlCallbackSelector<T, specialize IutlEnumerator<S>>.Create(aSelector));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_NESTED_PROCVARS}
generic function utlSelectMany<T, S>(
  constref aEnumerator: specialize IutlEnumerator<T>;
  constref aSelector: specialize TutlSelectEventN<T, specialize IutlEnumerator<S>>): specialize IutlEnumerator<S>;
begin
  result := specialize TutlSelectManyEnumerator<T, S>.Create(aEnumerator, specialize TutlCallbackSelector<T, specialize IutlEnumerator<S>>.Create(aSelector));
end;
{$ENDIF}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
generic function utlZip<T, S>(
  constref aEnumerator1: specialize IutlEnumerator<T>;
  constref aEnumerator2: specialize IutlEnumerator<S>): specialize IutlEnumerator<specialize TutlPair<T, S>>;
begin
  result := specialize TutlZipEnumerator<T, S>.Create(aEnumerator1, aEnumerator2);
end;
{$ENDIF}
{$ENDIF}

end.