implement Memoize

Author: sglienke

Source/Base/Collections/Spring.Collections.Base.pas

@@ -185,6 +185,8 @@   TEnumerableBase<T> = class abstract(TEnumerableBase)
     function Min(const comparer: IComparer<T>): T; overload;
     function Min(const comparer: TComparison<T>): T; overload;
 
+    function Memoize: IEnumerable<T>;
+
     function Ordered: IEnumerable<T>; overload;
     function Ordered(const comparer: IComparer<T>): IEnumerable<T>; overload;
     function Ordered(const comparer: TComparison<T>): IEnumerable<T>; overload;
@@ -260,7 +262,7 @@   TCollectionWrapper = class(TEnumerableWrapper, ICollection)
 
   TIteratorKind = (
     Partition, &Array,
-    Concat, Ordered, Reversed, Shuffled,
+    Concat, Memoize, Ordered, Reversed, Shuffled,
     SkipWhile, SkipWhileIndex,
     TakeWhile, TakeWhileIndex,
     Where, WhereIndex, Select);
@@ -292,6 +294,7 @@   TIteratorBlock = record
 
     function GetEnumerator: Boolean;
     function GetEnumeratorAndSkip: Boolean;
+    function GetEnumeratorMemoize: Boolean;
 
     function _Release: Integer; stdcall;
     function MoveNext: Boolean;
@@ -309,6 +312,15 @@   TIteratorBase = record
     function GetCountFast: Integer;
   end;
 
+  TMemoizeIterator<T> = record
+    // only used via pointer internally
+    // field layout has to match with TIteratorBase
+    Source: IEnumerable;
+    Enumerator: IEnumerator<T>;
+    Items: TArray<T>;
+    Index, Count: Integer;
+  end;
+
   TIteratorBase<T> = class abstract(TEnumerableBase<T>)
   private
     function HasLimit: Boolean; inline;
@@ -361,6 +373,7 @@   TIteratorBlock<T> = record
     function GetCurrent: T;
 
     function MoveNextConcat: Boolean;
+    function MoveNextMemoize: Boolean;
     function MoveNextOrdered: Boolean;
     function MoveNextReversed: Boolean;
     function MoveNextSkipWhile: Boolean;
@@ -1505,6 +1518,16 @@ function TEnumerableBase<T>.Min(const comparer: TComparison<T>): T;
   Result := IEnumerable<T>(this).Min(IComparer<T>(PPointer(@comparer)^));
 end;
 
+function TEnumerableBase<T>.Memoize: IEnumerable<T>;
+begin
+  if (GetInterfaceEntry(ICollectionOfTGuid) <> nil)
+    or (GetInterfaceEntry(IReadOnlyCollectionOfTGuid) <> nil) then
+    Result := IEnumerable<T>(this)
+  else
+    Result := TEnumerableIterator<T>.Create(IEnumerable<T>(this),
+      0, 0, nil, TIteratorKind.Memoize);
+end;
+
 function TEnumerableBase<T>.Ordered: IEnumerable<T>;
 begin
   Result := TEnumerableIterator<T>.Create(IEnumerable<T>(this),
@@ -3040,6 +3063,21 @@ function TIteratorBlock.GetEnumeratorAndSkip: Boolean;
   end;
 end;
 
+function TIteratorBlock.GetEnumeratorMemoize: Boolean;
+begin
+  if PIteratorBase(Predicate).fCount = 0 then
+  begin
+  {$IFDEF MSWINDOWS}
+    IEnumerableInternal(Source).GetEnumerator(IEnumerator(PIteratorBase(Predicate).fPredicate));
+  {$ELSE}
+    IEnumerator(PIteratorBase(Predicate).fPredicate) := Source.GetEnumerator;
+  {$ENDIF}
+    PIteratorBase(Predicate).fCount := PIteratorBase(Predicate).fCount or not CountMask;
+  end;
+  DoMoveNext := Methods.MoveNext;
+  Result := DoMoveNext(@Self);
+end;
+
 function TIteratorBlock.MoveNextEmpty: Boolean;
 begin
   Result := False;
@@ -3072,6 +3110,8 @@ class function TIteratorBlock<T>.Create(const iterator: TIteratorBase<T>): IEnum
     Count := iterator.fCount;
     Kind := iterator.fKind;
     Methods.Finalize := @TIteratorBlock<T>.Finalize;
+    if Kind = Memoize then
+      Pointer(Predicate) := @iterator.fSource;
   end;
   rec.InitMethods;
   rec.InitVtable;
@@ -3118,6 +3158,16 @@ procedure TIteratorBlock<T>.InitMethods;
       Methods.MoveNext := @TIteratorBlock<T>.MoveNextConcat;
       DoMoveNext := @TIteratorBlock.GetEnumerator;
     end;
+    TIteratorKind.Memoize:
+    begin
+      if Count = 0 then
+      begin
+        Methods.MoveNext := @TIteratorBlock<T>.MoveNextMemoize;
+        DoMoveNext := @TIteratorBlock.GetEnumeratorMemoize;
+      end
+      else
+        DoMoveNext := @TIteratorBlock<T>.MoveNextMemoize;
+    end;
     TIteratorKind.Ordered:
     begin
       Methods.MoveNext := @TIteratorBlock<T>.MoveNextOrdered;
@@ -3179,7 +3229,10 @@ function TIteratorBlock<T>.Finalize: Boolean;
 begin
   Enumerator := nil;
   Source := nil;
-  Predicate := nil;
+  if Kind <> Memoize then
+    Predicate := nil
+  else
+    Pointer(Predicate) := nil;
   Items := nil;
 {$IFDEF DELPHIXE7_UP}
   if IsManagedType(T) then
@@ -3282,6 +3335,44 @@ function TIteratorBlock<T>.MoveNextIndexed: Boolean;
   end;
 end;
 
+function TIteratorBlock<T>.MoveNextMemoize: Boolean;
+var
+  iterator: ^TMemoizeIterator<T>;
+  count, capacity: NativeInt;
+begin
+  iterator := Pointer(Predicate);
+  count := iterator.Count and CountMask;
+  if Index >= count then
+  begin
+    if iterator.Enumerator = nil then
+      Exit(False);
+
+    if not iterator.Enumerator.MoveNext then
+    begin
+      iterator.Enumerator := nil;
+      Exit(False);
+    end;
+
+    capacity := DynArrayLength(iterator.Items);
+    if count >= capacity then
+    begin
+      capacity := GrowCapacity(capacity);
+      SetLength(iterator.Items, capacity);
+    end;
+    {$IF defined(DELPHIXE7_UP) and defined(MSWINDOWS)}
+    if IsManagedType(T) then
+      IEnumeratorInternal(iterator.Enumerator).GetCurrent(iterator.Items[count])
+    else
+    {$IFEND}
+    iterator.Items[count] := iterator.Enumerator.Current;
+    Inc(iterator.Count);
+  end;
+
+  Current := iterator.Items[Index];
+  Inc(Index);
+  Result := True;
+end;
+
 function TIteratorBlock<T>.MoveNextOrdered: Boolean;
 begin
   if Index < Count then

Source/Base/Collections/Spring.Collections.pas

@@ -656,6 +656,14 @@ interface
     function Min(const comparer: IComparer<T>): T; overload;
     function Min(const comparer: TComparison<T>): T; overload;
 
+    /// <summary>
+    ///   Creates a sequence that lazily caches the source as it is iterated
+    ///   for the first time, reusing the cache thereafter for future
+    ///   re-iterations. If the source is already cached or buffered then it
+    ///   is returned verbatim.
+    /// </summary>
+    function Memoize: IEnumerable<T>;
+
     /// <summary>
     ///   Sorts the elements of a sequence in ascending order using the default
     ///   comparer for their type.