freepascal
/
utils
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

* auto reset enumerator

master
bergmann 8 years ago
parent
c8ab34ffcc
commit
799950db31
7 changed files with 439 additions and 375 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +5
    -3
      tests/tests.lpi
  2. +2
    -2
      tests/tests.lpr
  3. +149
    -152
      tests/tests.lps
  4. +23
    -23
      tests/uutlLinqTests.pas
  5. +215
    -156
      uutlEnumerator.pas
  6. +36
    -30
      uutlGenerics.pas
  7. +9
    -9
      uutlListBase.pas

+ 5
- 3
tests/tests.lpi View File

@@ -214,11 +214,13 @@
<CompilerMessages>
<IgnoredMessages idx5024="True"/>
</CompilerMessages>
<OtherDefines Count="4">
<CustomOptions Value="-dUTL_ADVANCED_ENUMERATORS
-dUTL_NESTED_PROCVARS
-dUTL_ENUMERATORS"/>
<OtherDefines Count="3">
<Define0 Value="UTL_ADVANCED_ENUMERATORS"/>
<Define1 Value="UTL_NESTED_PROCVARS"/>
<Define2 Value="UTL_DELPHI_GENERICS"/>
<Define3 Value="UTL_ENUMERATORS"/>
<Define2 Value="UTL_ENUMERATORS"/>
</OtherDefines>
</Other>
</CompilerOptions>


+ 2
- 2
tests/tests.lpr View File

@@ -9,6 +9,7 @@ uses
// test cases
uutlAlgorithmTests, uutlEnumeratorTests, uutlHashSetTests, uutlLinqTests,
uutlListTest, uutlMapTests, uutlQueueTests, uutlStackTests, uutlObservableListTests,
uutlObservableHashSetTests, uutlObservableMapTests

// test misc
uTestHelper,
@@ -16,8 +17,7 @@ uses
// units unter test
uutlAlgorithm, uutlArrayContainer, uutlCommon, uutlComparer, uutlEnumerator,
uutlFilter, uutlGenerics, uutlInterfaces, uutlLinq, uutlListBase, uutlLogger,
uutlStreamHelper, uutlSyncObjs, uutlTypes, uutlXmlHelper, uutlObservable, uutlObservableHashSetTests,
uutlObservableMapTests;
uutlStreamHelper, uutlSyncObjs, uutlTypes, uutlXmlHelper, uutlObservable;

{$R *.res}



+ 149
- 152
tests/tests.lps View File

@@ -8,7 +8,7 @@
<Unit0>
<Filename Value="tests.lpr"/>
<IsPartOfProject Value="True"/>
<EditorIndex Value="12"/>
<EditorIndex Value="13"/>
<CursorPos X="33" Y="13"/>
<UsageCount Value="75"/>
<Loaded Value="True"/>
@@ -16,15 +16,15 @@
<Unit1>
<Filename Value="..\uutlGenerics.pas"/>
<IsPartOfProject Value="True"/>
<TopLine Value="1297"/>
<CursorPos Y="1322"/>
<TopLine Value="315"/>
<CursorPos X="5" Y="331"/>
<UsageCount Value="75"/>
<Loaded Value="True"/>
</Unit1>
<Unit2>
<Filename Value="..\uutlArrayContainer.pas"/>
<IsPartOfProject Value="True"/>
<EditorIndex Value="10"/>
<EditorIndex Value="11"/>
<CursorPos X="11" Y="13"/>
<UsageCount Value="75"/>
<Loaded Value="True"/>
@@ -32,7 +32,7 @@
<Unit3>
<Filename Value="..\uutlCommon.pas"/>
<IsPartOfProject Value="True"/>
<EditorIndex Value="15"/>
<EditorIndex Value="16"/>
<TopLine Value="44"/>
<CursorPos X="3" Y="59"/>
<UsageCount Value="75"/>
@@ -42,8 +42,7 @@
<Filename Value="..\uutlListBase.pas"/>
<IsPartOfProject Value="True"/>
<EditorIndex Value="2"/>
<TopLine Value="155"/>
<CursorPos Y="170"/>
<CursorPos X="26" Y="24"/>
<UsageCount Value="75"/>
<Loaded Value="True"/>
</Unit4>
@@ -59,7 +58,7 @@
<Unit6>
<Filename Value="uutlQueueTests.pas"/>
<IsPartOfProject Value="True"/>
<EditorIndex Value="11"/>
<EditorIndex Value="12"/>
<TopLine Value="250"/>
<CursorPos X="49" Y="260"/>
<UsageCount Value="75"/>
@@ -123,16 +122,17 @@
<Unit14>
<Filename Value="..\uutlEnumerator.pas"/>
<IsPartOfProject Value="True"/>
<IsVisibleTab Value="True"/>
<EditorIndex Value="7"/>
<TopLine Value="469"/>
<CursorPos Y="489"/>
<TopLine Value="323"/>
<CursorPos X="42" Y="338"/>
<UsageCount Value="72"/>
<Loaded Value="True"/>
</Unit14>
<Unit15>
<Filename Value="uutlEnumeratorTests.pas"/>
<IsPartOfProject Value="True"/>
<EditorIndex Value="8"/>
<EditorIndex Value="9"/>
<TopLine Value="49"/>
<CursorPos X="8" Y="66"/>
<UsageCount Value="72"/>
@@ -149,7 +149,7 @@
<Unit17>
<Filename Value="..\uutlInterfaces.pas"/>
<IsPartOfProject Value="True"/>
<EditorIndex Value="16"/>
<EditorIndex Value="17"/>
<TopLine Value="22"/>
<CursorPos X="11" Y="37"/>
<UsageCount Value="68"/>
@@ -167,15 +167,16 @@
<Unit19>
<Filename Value="uutlLinqTests.pas"/>
<IsPartOfProject Value="True"/>
<EditorIndex Value="-1"/>
<TopLine Value="252"/>
<CursorPos X="30" Y="264"/>
<EditorIndex Value="8"/>
<TopLine Value="558"/>
<CursorPos X="61" Y="570"/>
<UsageCount Value="59"/>
<Loaded Value="True"/>
</Unit19>
<Unit20>
<Filename Value="..\uutlTypes.pas"/>
<IsPartOfProject Value="True"/>
<EditorIndex Value="17"/>
<EditorIndex Value="18"/>
<UsageCount Value="59"/>
<Loaded Value="True"/>
</Unit20>
@@ -268,7 +269,7 @@
<Unit31>
<Filename Value="..\uutlEvent.pas"/>
<IsPartOfProject Value="True"/>
<EditorIndex Value="14"/>
<EditorIndex Value="15"/>
<CursorPos X="11" Y="35"/>
<UsageCount Value="50"/>
<Loaded Value="True"/>
@@ -300,334 +301,330 @@
<UsageCount Value="42"/>
</Unit34>
<Unit35>
<Filename Value="uutlObservableHashSetTests.pas"/>
<IsPartOfProject Value="True"/>
<EditorIndex Value="-1"/>
<WindowIndex Value="-1"/>
<TopLine Value="129"/>
<CursorPos Y="146"/>
<UsageCount Value="22"/>
</Unit35>
<Unit36>
<Filename Value="uutlObservableMapTests.pas"/>
<IsPartOfProject Value="True"/>
<EditorIndex Value="3"/>
<CursorPos X="3" Y="13"/>
<UsageCount Value="21"/>
<Loaded Value="True"/>
</Unit36>
<Unit37>
<Filename Value="..\uutlExceptions.pas"/>
<EditorIndex Value="-1"/>
<CursorPos X="21" Y="3"/>
<UsageCount Value="32"/>
</Unit35>
<Unit36>
</Unit37>
<Unit38>
<Filename Value="_uutlInterfaces.pas"/>
<EditorIndex Value="-1"/>
<CursorPos X="42" Y="6"/>
<UsageCount Value="33"/>
</Unit36>
<Unit37>
</Unit38>
<Unit39>
<Filename Value="uutlArrayTests.pas"/>
<EditorIndex Value="-1"/>
<TopLine Value="9"/>
<CursorPos X="25" Y="38"/>
<UsageCount Value="32"/>
</Unit37>
<Unit38>
</Unit39>
<Unit40>
<Filename Value="..\uutlGenerics2.pas"/>
<EditorIndex Value="-1"/>
<WindowIndex Value="-1"/>
<TopLine Value="1902"/>
<CursorPos Y="1905"/>
<UsageCount Value="7"/>
</Unit38>
<Unit39>
</Unit40>
<Unit41>
<Filename Value="..\uutlCommon2.pas"/>
<EditorIndex Value="-1"/>
<WindowIndex Value="1"/>
<TopLine Value="9"/>
<CursorPos X="15" Y="26"/>
<UsageCount Value="7"/>
</Unit39>
<Unit40>
</Unit41>
<Unit42>
<Filename Value="uutlInterfaces2.pas"/>
<EditorIndex Value="-1"/>
<WindowIndex Value="1"/>
<TopLine Value="49"/>
<CursorPos X="35" Y="60"/>
<UsageCount Value="7"/>
</Unit40>
<Unit41>
</Unit42>
<Unit43>
<Filename Value="..\uutlAlgorithm2.pas"/>
<EditorIndex Value="-1"/>
<WindowIndex Value="1"/>
<TopLine Value="66"/>
<CursorPos X="5" Y="93"/>
<UsageCount Value="7"/>
</Unit41>
<Unit42>
</Unit43>
<Unit44>
<Filename Value="C:\Zusatzprogramme\Lazarus\fpc\3.1.1\source\rtl\objpas\objpas.pp"/>
<EditorIndex Value="9"/>
<TopLine Value="64"/>
<CursorPos X="19" Y="79"/>
<UsageCount Value="13"/>
<EditorIndex Value="10"/>
<TopLine Value="63"/>
<CursorPos X="20" Y="75"/>
<UsageCount Value="14"/>
<Loaded Value="True"/>
</Unit42>
<Unit43>
</Unit44>
<Unit45>
<Filename Value="G:\Eigene Datein\Projekte\_Active Projekte\TotoStarRedesign\utils\uutlAlgorithm.pas"/>
<EditorIndex Value="-1"/>
<WindowIndex Value="1"/>
<TopLine Value="48"/>
<CursorPos X="45" Y="56"/>
<UsageCount Value="7"/>
</Unit43>
<Unit44>
</Unit45>
<Unit46>
<Filename Value="..\uutlEnumerator2.pas"/>
<EditorIndex Value="-1"/>
<WindowIndex Value="1"/>
<TopLine Value="126"/>
<CursorPos X="22" Y="128"/>
<UsageCount Value="6"/>
</Unit44>
<Unit45>
</Unit46>
<Unit47>
<Filename Value="C:\Zusatzprogramme\Lazarus\components\fptest\src\FPCUnitCompatibleInterface.inc"/>
<EditorIndex Value="4"/>
<TopLine Value="90"/>
<CursorPos Y="105"/>
<UsageCount Value="14"/>
<UsageCount Value="15"/>
<Loaded Value="True"/>
</Unit45>
<Unit46>
</Unit47>
<Unit48>
<Filename Value="C:\Zusatzprogramme\Lazarus\components\fptest\src\TestFramework.pas"/>
<EditorIndex Value="-1"/>
<WindowIndex Value="1"/>
<TopLine Value="2692"/>
<CursorPos Y="2705"/>
<UsageCount Value="10"/>
</Unit46>
<Unit47>
</Unit48>
<Unit49>
<Filename Value="..\internal_uutlInterfaces.pas"/>
<EditorIndex Value="-1"/>
<CursorPos Y="11"/>
<UsageCount Value="6"/>
</Unit47>
<Unit48>
</Unit49>
<Unit50>
<Filename Value="..\uutlUtils.inc"/>
<EditorIndex Value="-1"/>
<CursorPos X="46" Y="3"/>
<UsageCount Value="7"/>
</Unit48>
<Unit49>
</Unit50>
<Unit51>
<Filename Value="C:\Zusatzprogramme\Lazarus\fpc\3.1.1\source\rtl\objpas\classes\classesh.inc"/>
<EditorIndex Value="-1"/>
<TopLine Value="118"/>
<CursorPos X="3" Y="143"/>
<UsageCount Value="13"/>
</Unit49>
<Unit50>
</Unit51>
<Unit52>
<Filename Value="G:\Eigene Datein\Projekte\_Active Projekte\TotoStarRedesign\utils\uutlCommon.pas"/>
<EditorIndex Value="-1"/>
<TopLine Value="474"/>
<CursorPos X="16" Y="500"/>
<UsageCount Value="9"/>
</Unit50>
<Unit51>
</Unit52>
<Unit53>
<Filename Value="C:\Zusatzprogramme\Lazarus\fpc\3.1.1\source\rtl\win\wininc\ascdef.inc"/>
<EditorIndex Value="-1"/>
<TopLine Value="202"/>
<CursorPos X="10" Y="217"/>
<UsageCount Value="8"/>
</Unit51>
<Unit52>
</Unit53>
<Unit54>
<Filename Value="G:\Eigene Datein\Projekte\_Active Projekte\TotoStarRedesign\utils\uutlSyncObjs.pas"/>
<EditorIndex Value="-1"/>
<WindowIndex Value="1"/>
<TopLine Value="64"/>
<CursorPos X="13" Y="76"/>
<UsageCount Value="14"/>
</Unit52>
<Unit53>
</Unit54>
<Unit55>
<Filename Value="C:\Zusatzprogramme\Lazarus\fpc\3.1.1\source\rtl\objpas\sysutils\sysutilh.inc"/>
<EditorIndex Value="-1"/>
<TopLine Value="97"/>
<CursorPos X="19" Y="112"/>
<UsageCount Value="14"/>
</Unit53>
<Unit54>
</Unit55>
<Unit56>
<Filename Value="C:\Zusatzprogramme\Lazarus\fpc\3.1.1\source\rtl\win\wininc\func.inc"/>
<EditorIndex Value="-1"/>
<TopLine Value="244"/>
<CursorPos X="10" Y="259"/>
<UsageCount Value="9"/>
</Unit54>
<Unit55>
</Unit56>
<Unit57>
<Filename Value="G:\Eigene Datein\Projekte\_Active Projekte\TotoStarRedesign\utils\uutlXmlHelper.pas"/>
<EditorIndex Value="-1"/>
<CursorPos X="29" Y="30"/>
<UsageCount Value="8"/>
</Unit55>
<Unit56>
</Unit57>
<Unit58>
<Filename Value="C:\Zusatzprogramme\Lazarus\fpc\3.1.1\source\packages\fcl-base\src\contnrs.pp"/>
<EditorIndex Value="-1"/>
<TopLine Value="136"/>
<CursorPos X="3" Y="151"/>
<UsageCount Value="9"/>
</Unit56>
<Unit57>
</Unit58>
<Unit59>
<Filename Value="..\uutlEmbeddedProfiler.inc"/>
<EditorIndex Value="-1"/>
<WindowIndex Value="-1"/>
<TopLine Value="-1"/>
<CursorPos X="-1" Y="-1"/>
<UsageCount Value="19"/>
</Unit57>
<Unit58>
</Unit59>
<Unit60>
<Filename Value="C:\Zusatzprogramme\Lazarus\fpc\3.1.1\source\rtl\inc\objpash.inc"/>
<EditorIndex Value="13"/>
<EditorIndex Value="14"/>
<TopLine Value="190"/>
<CursorPos X="23" Y="205"/>
<UsageCount Value="13"/>
<Loaded Value="True"/>
</Unit58>
<Unit59>
</Unit60>
<Unit61>
<Filename Value="C:\Zusatzprogramme\Lazarus\fpc\3.1.1\source\rtl\objpas\sysutils\osutilsh.inc"/>
<EditorIndex Value="-1"/>
<TopLine Value="40"/>
<CursorPos X="3" Y="62"/>
<UsageCount Value="12"/>
</Unit59>
<Unit60>
<Filename Value="uutlObservableHashSetTests.pas"/>
<IsPartOfProject Value="True"/>
<IsVisibleTab Value="True"/>
<EditorIndex Value="-1"/>
<WindowIndex Value="1"/>
<TopLine Value="129"/>
<CursorPos Y="146"/>
<UsageCount Value="21"/>
</Unit60>
<Unit61>
<Filename Value="uutlObservableMapTests.pas"/>
<IsPartOfProject Value="True"/>
<IsVisibleTab Value="True"/>
<EditorIndex Value="3"/>
<TopLine Value="113"/>
<CursorPos X="57" Y="130"/>
<UsageCount Value="21"/>
<Loaded Value="True"/>
</Unit61>
</Units>
<OtherDefines Count="4">
<OtherDefines Count="3">
<Define0 Value="UTL_ADVANCED_ENUMERATORS"/>
<Define1 Value="UTL_NESTED_PROCVARS"/>
<Define2 Value="UTL_DELPHI_GENERICS"/>
<Define3 Value="UTL_ENUMERATORS"/>
<Define2 Value="UTL_ENUMERATORS"/>
</OtherDefines>
<JumpHistory Count="30" HistoryIndex="29">
<Position1>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="487" TopLine="469"/>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="514" TopLine="495"/>
</Position1>
<Position2>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="488" TopLine="469"/>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1125" TopLine="1092"/>
</Position2>
<Position3>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="489" TopLine="469"/>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="502" Column="32" TopLine="497"/>
</Position3>
<Position4>
<Filename Value="..\uutlObservable.pas"/>
<Caret Line="639" TopLine="618"/>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1134" TopLine="1110"/>
</Position4>
<Position5>
<Filename Value="..\uutlObservable.pas"/>
<Caret Line="559" TopLine="544"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="45" Column="15" TopLine="31"/>
</Position5>
<Position6>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1012" TopLine="994"/>
<Caret Line="1163" TopLine="1143"/>
</Position6>
<Position7>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1361" TopLine="1346"/>
<Caret Line="1123" Column="39" TopLine="1108"/>
</Position7>
<Position8>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1351" TopLine="1345"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="44" Column="12" TopLine="31"/>
</Position8>
<Position9>
<Filename Value="uutlObservableMapTests.pas"/>
<Caret Line="70" TopLine="55"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="45" Column="15" TopLine="31"/>
</Position9>
<Position10>
<Filename Value="uutlObservableMapTests.pas"/>
<Caret Line="72" TopLine="55"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="105" Column="39" TopLine="90"/>
</Position10>
<Position11>
<Filename Value="uutlObservableMapTests.pas"/>
<Caret Line="73" TopLine="55"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="197" Column="39" TopLine="179"/>
</Position11>
<Position12>
<Filename Value="uutlObservableMapTests.pas"/>
<Caret Line="74" TopLine="55"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="220" Column="39" TopLine="203"/>
</Position12>
<Position13>
<Filename Value="uutlObservableMapTests.pas"/>
<Caret Line="68" TopLine="55"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="247" Column="39" TopLine="228"/>
</Position13>
<Position14>
<Filename Value="uutlObservableMapTests.pas"/>
<Caret Line="107" Column="16" TopLine="113"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="268" Column="3" TopLine="247"/>
</Position14>
<Position15>
<Filename Value="uutlObservableMapTests.pas"/>
<Caret Line="123" TopLine="113"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="297" Column="5" TopLine="271"/>
</Position15>
<Position16>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1312" TopLine="1297"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="322" Column="39" TopLine="303"/>
</Position16>
<Position17>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1314" TopLine="1297"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="352" Column="5" TopLine="326"/>
</Position17>
<Position18>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1315" TopLine="1297"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="373" Column="39" TopLine="356"/>
</Position18>
<Position19>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1316" TopLine="1297"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="286" Column="15" TopLine="271"/>
</Position19>
<Position20>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1317" TopLine="1297"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="524" Column="31" TopLine="509"/>
</Position20>
<Position21>
<Filename Value="uutlObservableMapTests.pas"/>
<Caret Line="128" Column="36" TopLine="113"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="542" Column="47" TopLine="521"/>
</Position21>
<Position22>
<Filename Value="uutlObservableMapTests.pas"/>
<Caret Line="123" TopLine="113"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="1042" TopLine="1017"/>
</Position22>
<Position23>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1312" TopLine="1297"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="980" TopLine="973"/>
</Position23>
<Position24>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1314" TopLine="1297"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="953" TopLine="925"/>
</Position24>
<Position25>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1315" TopLine="1297"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="897" TopLine="877"/>
</Position25>
<Position26>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1316" TopLine="1297"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="855" TopLine="833"/>
</Position26>
<Position27>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1317" TopLine="1297"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="813" TopLine="789"/>
</Position27>
<Position28>
<Filename Value="..\uutlGenerics.pas"/>
<Caret Line="1322" TopLine="1297"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="767" TopLine="744"/>
</Position28>
<Position29>
<Filename Value="..\uutlObservable.pas"/>
<Caret Line="573" TopLine="556"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="726" TopLine="699"/>
</Position29>
<Position30>
<Filename Value="..\uutlObservable.pas"/>
<Caret Line="572" Column="45" TopLine="556"/>
<Filename Value="..\uutlEnumerator.pas"/>
<Caret Line="553" Column="65" TopLine="531"/>
</Position30>
</JumpHistory>
</ProjectSession>


+ 23
- 23
tests/uutlLinqTests.pas View File

@@ -126,7 +126,7 @@ begin
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function CreateArrayEnumerator(const aSize: Integer; const aStartIndex: Integer = 1): TIntArrEnumerator.IEnumerator;
function CreateArrayEnumerator(const aSize: Integer; const aStartIndex: Integer = 1): TIntArrEnumerator.IutlEnumerator;
var
arr: array of Integer;
i: Integer;
@@ -138,7 +138,7 @@ begin
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function CreateArrayEnumerator(const aData: array of Integer): TIntArrEnumerator.IEnumerator;
function CreateArrayEnumerator(const aData: array of Integer): TIntArrEnumerator.IutlEnumerator;
var
arr: array of Integer;
i: Integer;
@@ -150,7 +150,7 @@ begin
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function CreateStringEnumerator(const aData: array of String): TStringArrEnumerator.IEnumerator;
function CreateStringEnumerator(const aData: array of String): TStringArrEnumerator.IutlEnumerator;
var
arr: array of String;
i: Integer;
@@ -166,7 +166,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Count;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := CreateArrayEnumerator(10);
AssertEquals(10, specialize utlCount<Integer>(e));
@@ -216,7 +216,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Reverse;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlReverse<Integer>(CreateArrayEnumerator(5));
e.Reset;
@@ -236,7 +236,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Skip;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlSkip<Integer>(CreateArrayEnumerator(5), 2);
e.Reset;
@@ -252,7 +252,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Take;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlTake<Integer>(CreateArrayEnumerator(5), 3);
e.Reset;
@@ -268,7 +268,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Concat;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlConcat<Integer>(
CreateArrayEnumerator(2, 1),
@@ -288,7 +288,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Concat_WithArray;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlConcat<Integer>(
specialize TutlArray<specialize IutlEnumerator<Integer>>.Create(
@@ -315,7 +315,7 @@ end;
{$IFDEF UTL_ADVANCED_ENUMERATORS}
procedure TutlLinqTests.proc_Sort;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlSort<Integer>(CreateArrayEnumerator([1, 5, 3, 6, 7, 9, 2]));
e.Reset;
@@ -339,7 +339,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Sort_WithComparer;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlSort<Integer>(CreateArrayEnumerator([1, 5, 3, 6, 7, 9, 2]), specialize TutlComparer<Integer>.Create);
e.Reset;
@@ -363,7 +363,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Where_WithFilter;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlWhere<Integer>(CreateArrayEnumerator(5), TCallbackObject.Create);
e.Reset;
@@ -377,7 +377,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Where_WithNormalCallback;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlWhere<Integer>(CreateArrayEnumerator(5), @TestFilter);
e.Reset;
@@ -391,7 +391,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Where_WithObjectCallback;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
o: TCallbackObject;
begin
o := TCallbackObject.Create;
@@ -418,7 +418,7 @@ procedure TutlLinqTests.proc_Where_WithNestedCallback;
end;

var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlWhereN<Integer>(CreateArrayEnumerator(5), @IsEventNested);
e.Reset;
@@ -433,7 +433,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Distinct;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlDistinct<Integer>(CreateArrayEnumerator([1, 4, 3, 6, 1, 3, 4, 7 ]));
e.Reset;
@@ -453,7 +453,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Distinct_WithComparer;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlDistinct<Integer>(CreateArrayEnumerator([1, 4, 3, 6, 1, 3, 4, 7 ]), specialize TutlComparer<Integer>.Create);
e.Reset;
@@ -473,7 +473,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Intersect;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlIntersect<Integer>(
CreateArrayEnumerator([ 1, 2, 3, 4, 5, 6, 7 ]),
@@ -491,7 +491,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Intersect_WithComparer;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlIntersect<Integer>(
CreateArrayEnumerator([ 1, 2, 3, 4, 5, 6, 7 ]),
@@ -510,7 +510,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Union;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlUnion<Integer>(
CreateArrayEnumerator([ 2, 4, 5, 7 ]),
@@ -534,7 +534,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Union_WithComparer;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlUnion<Integer>(
CreateArrayEnumerator([ 2, 4, 5, 7 ]),
@@ -559,7 +559,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Without;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlWithout<Integer>(
CreateArrayEnumerator([ 1, 2, 3, 4, 5, 6, 7 ]),
@@ -580,7 +580,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Without_WithComparer;
var
e: TIntArrEnumerator.IEnumerator;
e: TIntArrEnumerator.IutlEnumerator;
begin
e := specialize utlWithout<Integer>(
CreateArrayEnumerator([ 1, 2, 3, 4, 5, 6, 7 ]),


+ 215
- 156
uutlEnumerator.pas View File

@@ -20,9 +20,16 @@ type
, specialize IutlEnumerator<T>)

public type
TStatus = (
stCreated,
stReseted,
stMoving,
stFinished
);

{$IFDEF UTL_ENUMERATORS}
TArray = specialize TutlArray<T>;
IEnumerator = specialize IutlEnumerator<T>;
IutlEnumerator = specialize IutlEnumerator<T>;
IEqualityComparer = specialize IutlEqualityComparer<T>;
{$IFDEF UTL_ADVANCED_ENUMERATORS}
IComparer = specialize IutlComparer<T>;
@@ -30,35 +37,46 @@ type
{$ENDIF}
{$ENDIF}

strict private
fStatus: TStatus;
fAutoReset: Boolean;

protected
function InternalMoveNext: Boolean; virtual; abstract;
procedure InternalReset; virtual; abstract;

public { IEnumerator }
function GetCurrent: T; virtual; abstract;
function MoveNext: Boolean; virtual; abstract;
procedure Reset; virtual; abstract;
function GetCurrent: T; virtual; abstract;
function MoveNext: Boolean;
procedure Reset;

{$IFDEF UTL_ENUMERATORS}
public { IutlEnumerator }
function GetEnumerator: IEnumerator; virtual;
function GetEnumerator: IutlEnumerator; virtual;

function Count (): Integer; virtual;
function Any (): Boolean; virtual;
function ToArray (): TArray; virtual;
function Contains (constref aElement: T; aComparer: IEqualityComparer): Boolean; virtual;

function Skip (aCount: Integer): IEnumerator; virtual;
function Take (aCount: Integer): IEnumerator; virtual;
function Concat (aEnumerator: IEnumerator): IEnumerator; virtual;
function Reverse (): IEnumerator; virtual;
function Skip (aCount: Integer): IutlEnumerator; virtual;
function Take (aCount: Integer): IutlEnumerator; virtual;
function Concat (aEnumerator: IutlEnumerator): IutlEnumerator; virtual;
function Reverse (): IutlEnumerator; virtual;
{$IFDEF UTL_ADVANCED_ENUMERATORS}
function Sort (aComparer: IComparer): IEnumerator; virtual;
function Where (aFilter: IFilter): IEnumerator; virtual;
function Distinct (aComparer: IComparer): IEnumerator; virtual;
function Intersect(aEnumerator: IEnumerator; aComparer: IComparer): IEnumerator; virtual;
function Union (aEnumerator: IEnumerator; aComparer: IComparer): IEnumerator; virtual;
function Without (aEnumerator: IEnumerator; aComparer: IComparer): IEnumerator; virtual;
function Sort (aComparer: IComparer): IutlEnumerator; virtual;
function Where (aFilter: IFilter): IutlEnumerator; virtual;
function Distinct (aComparer: IComparer): IutlEnumerator; virtual;
function Intersect(aEnumerator: IutlEnumerator; aComparer: IComparer): IutlEnumerator; virtual;
function Union (aEnumerator: IutlEnumerator; aComparer: IComparer): IutlEnumerator; virtual;
function Without (aEnumerator: IutlEnumerator; aComparer: IComparer): IutlEnumerator; virtual;
{$ENDIF}
{$ENDIF}

public
property Status: TStatus read fStatus;
property AutoReset: Boolean read fAutoReset write fAutoReset;

constructor Create;
end;

@@ -82,10 +100,12 @@ type
property First: Integer read fFirst write fFirst;
property Last: Integer read fLast write fLast;

protected { TutlEnumerator }
function InternalMoveNext: Boolean; override;
procedure InternalReset; override;

public { IEnumerator }
function GetCurrent: T; override;
function MoveNext: Boolean; override;
procedure Reset; override;

{$IFDEF UTL_ADVANCED_ENUMERATORS}
public { IutlEnumerator }
@@ -118,7 +138,7 @@ type
fData: TArray;

public { IEnumerator }
procedure Reset; override;
procedure InternalReset; override;

public
property Data: TArray read fData write fData;
@@ -134,13 +154,13 @@ type
specialize TutlArrayEnumerator<T>)

strict private
fEnumerator: IEnumerator;
fEnumerator: IutlEnumerator;

public { IEnumerator }
procedure Reset; override;
procedure InternalReset; override;

public
constructor Create(aEnumerator: IEnumerator); reintroduce;
constructor Create(aEnumerator: IutlEnumerator); reintroduce;
end;
{$ENDIF}

@@ -150,14 +170,14 @@ type
specialize TutlArrayEnumerator<T>)

strict private
fEnumerator: IEnumerator;
fEnumerator: IutlEnumerator;
fComparer: IComparer;

public { IEnumerator }
procedure Reset; override;
procedure InternalReset; override;

public
constructor Create(aEnumerator: IEnumerator; aComparer: IComparer); reintroduce;
constructor Create(aEnumerator: IutlEnumerator; aComparer: IComparer); reintroduce;
end;
{$ENDIF}

@@ -167,18 +187,20 @@ type
specialize TutlEnumerator<T>)

strict private
fEnumerator: IEnumerator;
fEnumerator: IutlEnumerator;
fComparer: IComparer;
fCurrent: T;
fData: array of T;

protected { TutlEnumerator }
function InternalMoveNext: Boolean; override;
procedure InternalReset; override;

public { IEnumerator }
function GetCurrent: T; override;
function MoveNext: Boolean; override;
procedure Reset; override;

public
constructor Create(aEnumerator: IEnumerator; aComparer: IComparer); reintroduce;
constructor Create(aEnumerator: IutlEnumerator; aComparer: IComparer); reintroduce;
end;
{$ENDIF}

@@ -189,22 +211,24 @@ type

strict private
fWithoutMode: Boolean;
fEnumerator: IEnumerator;
fOther: IEnumerator;
fEnumerator: IutlEnumerator;
fOther: IutlEnumerator;
fComparer: IComparer;
fData: array of T;
fCurrent: T;

protected { TutlEnumerator }
function InternalMoveNext: Boolean; override;
procedure InternalReset; override;

public { IEnumerator }
function GetCurrent: T; override;
function MoveNext: Boolean; override;
procedure Reset; override;

public
constructor Create(
const aWithoutMode: Boolean;
aEnumerator: IEnumerator;
aOther: IEnumerator;
aEnumerator: IutlEnumerator;
aOther: IutlEnumerator;
aComparer: IComparer); reintroduce;
end;
{$ENDIF}
@@ -214,19 +238,21 @@ type
specialize TutlEnumerator<T>)

strict private
fEnumerator: IEnumerator;
fEnumerator: IutlEnumerator;
fSkip: Integer; // greater than 0: skip X; lower than 0: skip none
fTake: Integer; // greater than 0: take X; lower than 0: take all
fCurrentSkip: Integer;
fCurrentTake: Integer;

protected { TutlEnumerator }
function InternalMoveNext: Boolean; override;
procedure InternalReset; override;

public { IEnumerator }
function GetCurrent: T; override;
function MoveNext: Boolean; override;
procedure Reset; override;

public
constructor Create(aEnumerator: IEnumerator; const aSkip: Integer; const aTake: Integer);
constructor Create(aEnumerator: IutlEnumerator; const aSkip: Integer; const aTake: Integer);
destructor Destroy; override;
end;

@@ -236,16 +262,18 @@ type
specialize TutlEnumerator<T>)

strict private
fEnumerator: IEnumerator;
fEnumerator: IutlEnumerator;
fFilter: IFilter;

protected { TutlEnumerator }
function InternalMoveNext: Boolean; override;
procedure InternalReset; override;

public { IEnumerator }
function GetCurrent: T; override;
function MoveNext: Boolean; override;
procedure Reset; override;

public
constructor Create(aEnumerator: IEnumerator; aFilter: IFilter);
constructor Create(aEnumerator: IutlEnumerator; aFilter: IFilter);
destructor Destroy; override;
end;
{$ENDIF}
@@ -263,10 +291,12 @@ type
fEnumerator: IInEnumerator;
fSelector: ISelector;

protected { TutlEnumerator }
function InternalMoveNext: Boolean; override;
procedure InternalReset; override;

public { IEnumerator }
function GetCurrent: Tout; override;
function MoveNext: Boolean; override;
procedure Reset; override;

public
constructor Create(aEnumerator: IInEnumerator; aSelector: ISelector);
@@ -289,10 +319,12 @@ type
fSelector: ISelector;
fCurrent: IOutEnumerator;

protected { TutlEnumerator }
function InternalMoveNext: Boolean; override;
procedure InternalReset; override;

public { IEnumerator }
function GetCurrent: Tout; override;
function MoveNext: Boolean; override;
procedure Reset; override;

public
constructor Create(aEnumerator: IInEnumerator; aSelector: ISelector);
@@ -314,10 +346,12 @@ type
fEnumeratorT: IEnumeratorT;
fEnumeratorS: IEnumeratorS;

protected { TutlEnumerator }
function InternalMoveNext: Boolean; override;
procedure InternalReset; override;

public { IEnumerator }
function GetCurrent: TPair; override;
function MoveNext: Boolean; override;
procedure Reset; override;

public
constructor Create(aEnumeratorT: IEnumeratorT; aEnumeratorS: IEnumeratorS);
@@ -330,16 +364,18 @@ type
specialize TutlEnumerator<T>)

public type
TEnumerators = array of IEnumerator;
TEnumerators = array of IutlEnumerator;

strict private
fEnumerators: TEnumerators;
fCurrent: Integer;

protected { TutlEnumerator }
function InternalMoveNext: Boolean; override;
procedure InternalReset; override;

public { IEnumerator }
function GetCurrent: T; override;
function MoveNext: Boolean; override;
procedure Reset; override;

public
constructor Create(aEnumerators: TEnumerators);
@@ -350,9 +386,31 @@ implementation

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlEnumerator////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlEnumerator.MoveNext: Boolean;
begin
if (fStatus = stCreated)
or ( fAutoReset
and (fStatus = stFinished))
then
Reset;
result := InternalMoveNext;
if not result then
fStatus := stFinished
else if (fStatus = stReseted) then
fStatus := stMoving;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumerator.Reset;
begin
InternalReset;
fStatus := stReseted;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_ENUMERATORS}
function TutlEnumerator.GetEnumerator: IEnumerator;
function TutlEnumerator.GetEnumerator: IutlEnumerator;
begin
result := self;
end;
@@ -398,19 +456,19 @@ begin
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlEnumerator.Skip(aCount: Integer): IEnumerator;
function TutlEnumerator.Skip(aCount: Integer): IutlEnumerator;
begin
result := specialize TutlSkipTakeEnumerator<T>.Create(self, aCount, -1);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlEnumerator.Take(aCount: Integer): IEnumerator;
function TutlEnumerator.Take(aCount: Integer): IutlEnumerator;
begin
result := specialize TutlSkipTakeEnumerator<T>.Create(self, -1, aCount);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlEnumerator.Concat(aEnumerator: IEnumerator): IEnumerator;
function TutlEnumerator.Concat(aEnumerator: IutlEnumerator): IutlEnumerator;
type
TConcatEnumerator = specialize TutlConcatEnumerator<T>;
begin
@@ -418,44 +476,44 @@ begin
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlEnumerator.Reverse: IEnumerator;
function TutlEnumerator.Reverse: IutlEnumerator;
begin
result := specialize TutlReverseEnumerator<T>.Create(self);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_ADVANCED_ENUMERATORS}
function TutlEnumerator.Sort(aComparer: IComparer): IEnumerator;
function TutlEnumerator.Sort(aComparer: IComparer): IutlEnumerator;
begin
result := specialize TutlSortEnumerator<T>.Create(self, aComparer);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlEnumerator.Where(aFilter: IFilter): IEnumerator;
function TutlEnumerator.Where(aFilter: IFilter): IutlEnumerator;
begin
result := specialize TutlWhereEnumerator<T>.Create(self, aFilter);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlEnumerator.Distinct(aComparer: IComparer): IEnumerator;
function TutlEnumerator.Distinct(aComparer: IComparer): IutlEnumerator;
begin
result := specialize TutlDistinctEnumerator<T>.Create(self, aComparer);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlEnumerator.Intersect(aEnumerator: IEnumerator; aComparer: IComparer): IEnumerator;
function TutlEnumerator.Intersect(aEnumerator: IutlEnumerator; aComparer: IComparer): IutlEnumerator;
begin
result := specialize TutlIntersectWithoutEnumerator<T>.Create(false, self, aEnumerator, aComparer);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlEnumerator.Union(aEnumerator: IEnumerator; aComparer: IComparer): IEnumerator;
function TutlEnumerator.Union(aEnumerator: IutlEnumerator; aComparer: IComparer): IutlEnumerator;
begin
result := Concat(aEnumerator).Distinct(aComparer);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlEnumerator.Without(aEnumerator: IEnumerator; aComparer: IComparer): IEnumerator;
function TutlEnumerator.Without(aEnumerator: IutlEnumerator; aComparer: IComparer): IutlEnumerator;
begin
result := specialize TutlIntersectWithoutEnumerator<T>.Create(true, self, aEnumerator, aComparer);
end;
@@ -466,21 +524,14 @@ end;
constructor TutlEnumerator.Create;
begin
inherited Create;
Reset;
fStatus := stCreated;
fAutoReset := false;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlMemoryEnumerator//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlMemoryEnumerator.{%H-}GetCurrent: T;
begin
if not Assigned(fMemory) or (fCurrent < fFirst) or (fCurrent > fLast) then
raise EInvalidOperation.Create('enumerator is not initialized');
result := (fMemory + fCurrent)^;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlMemoryEnumerator.MoveNext: Boolean;
function TutlMemoryEnumerator.InternalMoveNext: Boolean;
begin
if fReverse
then dec(fCurrent)
@@ -489,13 +540,21 @@ begin
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlMemoryEnumerator.Reset;
procedure TutlMemoryEnumerator.InternalReset;
begin
if fReverse
then fCurrent := fLast + 1
else fCurrent := fFirst - 1;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlMemoryEnumerator.{%H-}GetCurrent: T;
begin
if not Assigned(fMemory) or (fCurrent < fFirst) or (fCurrent > fLast) then
raise EInvalidOperation.Create('enumerator is not initialized');
result := (fMemory + fCurrent)^;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_ADVANCED_ENUMERATORS}
function TutlMemoryEnumerator.Count: Integer;
@@ -549,12 +608,12 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlArrayEnumerator///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlArrayEnumerator.Reset;
procedure TutlArrayEnumerator.InternalReset;
begin
Memory := @fData[0];
First := low(fData);
Last := high(fData);
inherited Reset;
inherited InternalReset;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -580,15 +639,15 @@ end;
//TutlReverseEnumerator/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_ENUMERATORS}
procedure TutlReverseEnumerator.Reset;
procedure TutlReverseEnumerator.InternalReset;
begin
Data := fEnumerator.ToArray;
Reverse := true;
inherited Reset;
inherited InternalReset;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor TutlReverseEnumerator.Create(aEnumerator: IEnumerator);
constructor TutlReverseEnumerator.Create(aEnumerator: IutlEnumerator);
begin
inherited Create;
fEnumerator := aEnumerator;
@@ -599,7 +658,7 @@ end;
//TutlSortEnumerator////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IF DEFINED(UTL_ENUMERATORS) AND DEFINED(UTL_ADVANCED_ENUMERATORS)}
procedure TutlSortEnumerator.Reset;
procedure TutlSortEnumerator.InternalReset;
type
TBinarySearch = specialize TutlBinarySearch<T>;
var
@@ -622,11 +681,11 @@ begin
Data := arr;
First := low(arr);
Last := high(arr);
inherited Reset;
inherited InternalReset;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor TutlSortEnumerator.Create(aEnumerator: IEnumerator; aComparer: IComparer);
constructor TutlSortEnumerator.Create(aEnumerator: IutlEnumerator; aComparer: IComparer);
begin
inherited Create;
fEnumerator := aEnumerator;
@@ -637,14 +696,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlDistinctEnumerator////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IF DEFINED(UTL_ENUMERATORS) AND DEFINED(UTL_ADVANCED_ENUMERATORS)}
function TutlDistinctEnumerator.GetCurrent: T;
begin
result := fCurrent;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlDistinctEnumerator.MoveNext: Boolean;
function TutlDistinctEnumerator.InternalMoveNext: Boolean;
type
TBinarySearch = specialize TutlBinarySearch<T>;
var
@@ -664,14 +716,21 @@ begin
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlDistinctEnumerator.Reset;
procedure TutlDistinctEnumerator.InternalReset;
begin
SetLength(fData, 0);
fEnumerator.Reset;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor TutlDistinctEnumerator.Create(aEnumerator: IEnumerator; aComparer: IComparer);
{$IF DEFINED(UTL_ENUMERATORS) AND DEFINED(UTL_ADVANCED_ENUMERATORS)}
function TutlDistinctEnumerator.GetCurrent: T;
begin
result := fCurrent;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor TutlDistinctEnumerator.Create(aEnumerator: IutlEnumerator; aComparer: IComparer);
begin
inherited Create;
fEnumerator := aEnumerator;
@@ -682,14 +741,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlIntersectWithoutEnumerator////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IF DEFINED(UTL_ENUMERATORS) AND DEFINED(UTL_ADVANCED_ENUMERATORS)}
function TutlIntersectWithoutEnumerator.GetCurrent: T;
begin
result := fCurrent;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlIntersectWithoutEnumerator.MoveNext: Boolean;
function TutlIntersectWithoutEnumerator.InternalMoveNext: Boolean;
type
TBinarySearch = specialize TutlBinarySearch<T>;
var
@@ -705,17 +757,24 @@ begin
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlIntersectWithoutEnumerator.Reset;
procedure TutlIntersectWithoutEnumerator.InternalReset;
begin
fEnumerator.Reset;
fData := fOther.Distinct(fComparer).Sort(fComparer).ToArray();
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IF DEFINED(UTL_ENUMERATORS) AND DEFINED(UTL_ADVANCED_ENUMERATORS)}
function TutlIntersectWithoutEnumerator.GetCurrent: T;
begin
result := fCurrent;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor TutlIntersectWithoutEnumerator.Create(
const aWithoutMode: Boolean;
aEnumerator: IEnumerator;
aOther: IEnumerator;
aEnumerator: IutlEnumerator;
aOther: IutlEnumerator;
aComparer: IComparer);
begin
inherited Create;
@@ -729,13 +788,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlSkipTakeEnumerator////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlSkipTakeEnumerator.GetCurrent: T;
begin
result := fEnumerator.Current;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlSkipTakeEnumerator.MoveNext: Boolean;
function TutlSkipTakeEnumerator.InternalMoveNext: Boolean;
begin
while (fCurrentSkip > 0) and fEnumerator.MoveNext do
dec(fCurrentSkip);
@@ -749,7 +802,7 @@ begin
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlSkipTakeEnumerator.Reset;
procedure TutlSkipTakeEnumerator.InternalReset;
begin
fEnumerator.Reset;
fCurrentSkip := fSkip;
@@ -757,7 +810,13 @@ begin
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor TutlSkipTakeEnumerator.Create(aEnumerator: IEnumerator; const aSkip: Integer; const aTake: Integer);
function TutlSkipTakeEnumerator.GetCurrent: T;
begin
result := fEnumerator.Current;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor TutlSkipTakeEnumerator.Create(aEnumerator: IutlEnumerator; const aSkip: Integer; const aTake: Integer);
begin
if not Assigned(aEnumerator) then
raise EArgumentNilException.Create('aEnumerator');
@@ -779,14 +838,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlWhereEnumerator///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IF DEFINED(UTL_ENUMERATORS) AND DEFINED(UTL_ADVANCED_ENUMERATORS)}
function TutlWhereEnumerator.GetCurrent: T;
begin
result := fEnumerator.Current;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlWhereEnumerator.MoveNext: Boolean;
function TutlWhereEnumerator.InternalMoveNext: Boolean;
begin
repeat
result := fEnumerator.MoveNext;
@@ -794,13 +846,20 @@ begin
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlWhereEnumerator.Reset;
procedure TutlWhereEnumerator.InternalReset;
begin
fEnumerator.Reset;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor TutlWhereEnumerator.Create(aEnumerator: IEnumerator; aFilter: IFilter);
{$IF DEFINED(UTL_ENUMERATORS) AND DEFINED(UTL_ADVANCED_ENUMERATORS)}
function TutlWhereEnumerator.GetCurrent: T;
begin
result := fEnumerator.Current;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor TutlWhereEnumerator.Create(aEnumerator: IutlEnumerator; aFilter: IFilter);
begin
if not Assigned(aEnumerator) then
raise EArgumentNilException.Create('aEnumerator');
@@ -823,22 +882,22 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlSelectEnumerator//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IF DEFINED(UTL_ENUMERATORS) AND DEFINED(UTL_ADVANCED_ENUMERATORS)}
function TutlSelectEnumerator.GetCurrent: Tout;
function TutlSelectEnumerator.InternalMoveNext: Boolean;
begin
result := fSelector.Select(fEnumerator.Current);
result := fEnumerator.MoveNext;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlSelectEnumerator.MoveNext: Boolean;
procedure TutlSelectEnumerator.InternalReset;
begin
result := fEnumerator.MoveNext;
fEnumerator.Reset;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlSelectEnumerator.Reset;
{$IF DEFINED(UTL_ENUMERATORS) AND DEFINED(UTL_ADVANCED_ENUMERATORS)}
function TutlSelectEnumerator.GetCurrent: Tout;
begin
fEnumerator.Reset;
result := fSelector.Select(fEnumerator.Current);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -866,15 +925,7 @@ end;
//TutlSelectManyEnumerator//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IF DEFINED(UTL_ENUMERATORS) AND DEFINED(UTL_ADVANCED_ENUMERATORS)}
function TutlSelectManyEnumerator.GetCurrent: Tout;
begin
if not Assigned(fCurrent) then
raise EInvalidOperation.Create('enumerator is not initialized');
result := fCurrent.GetCurrent;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlSelectManyEnumerator.MoveNext: Boolean;
function TutlSelectManyEnumerator.InternalMoveNext: Boolean;
begin
result := false;
while not result do begin
@@ -892,12 +943,20 @@ begin
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlSelectManyEnumerator.Reset;
procedure TutlSelectManyEnumerator.InternalReset;
begin
fEnumerator.Reset;
fCurrent := nil;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlSelectManyEnumerator.GetCurrent: Tout;
begin
if not Assigned(fCurrent) then
raise EInvalidOperation.Create('enumerator is not initialized');
result := fCurrent.GetCurrent;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor TutlSelectManyEnumerator.Create(aEnumerator: IInEnumerator; aSelector: ISelector);
begin
@@ -919,23 +978,23 @@ end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IF DEFINED(UTL_ENUMERATORS) AND DEFINED(UTL_ADVANCED_ENUMERATORS)}
function TutlZipEnumerator.GetCurrent: TPair;
function TutlZipEnumerator.InternalMoveNext: Boolean;
begin
result.First := fEnumeratorT.GetCurrent;
result.Second := fEnumeratorS.GetCurrent;
result := fEnumeratorT.MoveNext and fEnumeratorS.MoveNext;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlZipEnumerator.MoveNext: Boolean;
procedure TutlZipEnumerator.InternalReset;
begin
result := fEnumeratorT.MoveNext and fEnumeratorS.MoveNext;
fEnumeratorT.Reset;
fEnumeratorS.Reset;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlZipEnumerator.Reset;
function TutlZipEnumerator.GetCurrent: TPair;
begin
fEnumeratorT.Reset;
fEnumeratorS.Reset;
result.First := fEnumeratorT.GetCurrent;
result.Second := fEnumeratorS.GetCurrent;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -958,15 +1017,7 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlConcatEnumerator//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlConcatEnumerator.{%H-}GetCurrent: T;
begin
if (fCurrent < low(fEnumerators)) or (fCurrent > high(fEnumerators)) then
raise EInvalidOperation.Create('enumerator is not initialized');
result := fEnumerators[fCurrent].Current;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlConcatEnumerator.MoveNext: Boolean;
function TutlConcatEnumerator.InternalMoveNext: Boolean;
begin
if (fCurrent < 0) then begin
fCurrent := 0;
@@ -983,11 +1034,19 @@ begin
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlConcatEnumerator.Reset;
procedure TutlConcatEnumerator.InternalReset;
begin
fCurrent := -1;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlConcatEnumerator.{%H-}GetCurrent: T;
begin
if (fCurrent < low(fEnumerators)) or (fCurrent > high(fEnumerators)) then
raise EInvalidOperation.Create('enumerator is not initialized');
result := fEnumerators[fCurrent].Current;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor TutlConcatEnumerator.Create(aEnumerators: TEnumerators);
begin


+ 36
- 30
uutlGenerics.pas View File

@@ -26,10 +26,12 @@ type
fOwner: TutlQueue;
fCurrent: Integer;

protected { TutlEnumerator }
function InternalMoveNext: Boolean; override;
procedure InternalReset; override;

public { IEnumerator }
function GetCurrent: T; override;
function MoveNext: Boolean; override;
procedure Reset; override;

public
constructor Create(const aOwner: TutlQueue);
@@ -94,7 +96,7 @@ type
fOwner: TutlStack;

public { IEnumerator }
procedure Reset; override;
procedure InternalReset; override;

public
constructor Create(const aOwner: TutlStack); reintroduce;
@@ -306,10 +308,12 @@ type
strict private
fEnumerator: IutlKeyValuePairEnumerator;

protected { TutlEnumerator }
function InternalMoveNext: Boolean; override;
procedure InternalReset; override;

public { IEnumerator }
function GetCurrent: TKey; override;
function MoveNext: Boolean; override;
procedure Reset; override;
function GetCurrent: TKey; override;

public
constructor Create(aEnumerator: IutlKeyValuePairEnumerator);
@@ -324,10 +328,12 @@ type
strict private
fEnumerator: IutlKeyValuePairEnumerator;

protected { TutlEnumerator }
function InternalMoveNext: Boolean; override;
procedure InternalReset; override;

public { IEnumerator }
function GetCurrent: TValue; override;
function MoveNext: Boolean; override;
procedure Reset; override;
function GetCurrent: TValue; override;

public
constructor Create(aEnumerator: IutlKeyValuePairEnumerator);
@@ -493,22 +499,22 @@ implementation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlQueue.TEnumerator/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlQueue.TEnumerator.GetCurrent: T;
function TutlQueue.TEnumerator.InternalMoveNext: Boolean;
begin
result := fOwner[fCurrent];
inc(fCurrent);
result := (fCurrent < fOwner.Count);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlQueue.TEnumerator.MoveNext: Boolean;
procedure TutlQueue.TEnumerator.InternalReset;
begin
inc(fCurrent);
result := (fCurrent < fOwner.Count);
fCurrent := -1;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueue.TEnumerator.Reset;
function TutlQueue.TEnumerator.GetCurrent: T;
begin
fCurrent := -1;
result := fOwner[fCurrent];
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -682,14 +688,14 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlStack.TEnumerator/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlStack.TEnumerator.Reset;
procedure TutlStack.TEnumerator.InternalReset;
begin
First := 0;
Last := fOwner.Count-1;
if (Last >= First)
then Memory := fOwner.GetInternalItem(0)
else Memory := nil;
inherited Reset;
inherited InternalReset;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1114,21 +1120,21 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlCustomMap.TKeyEnumerator//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlCustomMap.TKeyEnumerator.GetCurrent: TKey;
function TutlCustomMap.TKeyEnumerator.InternalMoveNext: Boolean;
begin
result := fEnumerator.GetCurrent.Key;
result := fEnumerator.MoveNext;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlCustomMap.TKeyEnumerator.MoveNext: Boolean;
procedure TutlCustomMap.TKeyEnumerator.InternalReset;
begin
result := fEnumerator.MoveNext;
fEnumerator.Reset;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlCustomMap.TKeyEnumerator.Reset;
function TutlCustomMap.TKeyEnumerator.GetCurrent: TKey;
begin
fEnumerator.Reset;
result := fEnumerator.GetCurrent.Key;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1143,21 +1149,21 @@ end;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlCustomMap.TValueEnumerator////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlCustomMap.TValueEnumerator.GetCurrent: TValue;
function TutlCustomMap.TValueEnumerator.InternalMoveNext: Boolean;
begin
result := fEnumerator.GetCurrent.Value;
result := fEnumerator.MoveNext;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlCustomMap.TValueEnumerator.MoveNext: Boolean;
procedure TutlCustomMap.TValueEnumerator.InternalReset;
begin
result := fEnumerator.MoveNext;
fEnumerator.Reset;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlCustomMap.TValueEnumerator.Reset;
function TutlCustomMap.TValueEnumerator.GetCurrent: TValue;
begin
fEnumerator.Reset;
result := fEnumerator.GetCurrent.Value;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


+ 9
- 9
uutlListBase.pas View File

@@ -15,25 +15,25 @@ type
, specialize IEnumerable<T>
, specialize IutlEnumerable<T>)

public type
IEnumerator = specialize IEnumerator<T>;
IutlEnumerator = specialize IutlEnumerator<T>;

private type
TEnumerator = class(
specialize TutlMemoryEnumerator<T>
, specialize IEnumerator<T>
, specialize IutlEnumerator<T>)
, IEnumerator
, IutlEnumerator)
private
fOwner: TutlListBase;

public { IEnumerator }
procedure Reset; override;
procedure InternalReset; override;

public
constructor Create(const aOwner: TutlListBase); reintroduce;
end;

public type
IEnumerator = specialize IEnumerator<T>;
IutlEnumerator = specialize IutlEnumerator<T>;

strict private
fCount: Integer;

@@ -76,14 +76,14 @@ uses
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlListBase.TEnumerator//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlListBase.TEnumerator.Reset;
procedure TutlListBase.TEnumerator.InternalReset;
begin
First := 0;
Last := fOwner.Count-1;
if (Last >= First)
then Memory := fOwner.GetInternalItem(0)
else Memory := nil;
inherited Reset;
inherited InternalReset;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


Write Preview
Loading…
Cancel
Save