Add demo project with examples from online docs

Author: delphidabbler

Demos/ArrayUtilsDemo.dpr

@@ -0,0 +1,107 @@
+{
+ * Demo project for the DelphiDabbler.Lib.ArrayUtils unit.
+ *
+ * Contains copies the example code of all TArrayUtils methods included in the
+ * documentation at https://delphidabbler.com/url/arrayutils-docs.
+ *
+ * This is a console application.
+ *
+ * Any copyright in this file is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+}
+
+program ArrayUtilsDemo;
+
+{$APPTYPE CONSOLE}
+
+uses
+  SysUtils,
+  DelphiDabbler.Lib.ArrayUtils in '..\DelphiDabbler.Lib.ArrayUtils.pas',
+  Registrar in 'Registrar.pas',
+  Chop in 'Examples\Chop.pas',
+  Compare in 'Examples\Compare.pas',
+  Concat in 'Examples\Concat.pas',
+  Contains in 'Examples\Contains.pas',
+  Copy in 'Examples\Copy.pas',
+  CopyReversed in 'Examples\CopyReversed.pas',
+  CopySorted in 'Examples\CopySorted.pas',
+  DeDup in 'Examples\DeDup.pas',
+  Delete in 'Examples\Delete.pas',
+  DeleteAndFree in 'Examples\DeleteAndFree.pas',
+  DeleteAndFreeRange in 'Examples\DeleteAndFreeRange.pas',
+  DeleteAndRelease in 'Examples\DeleteAndRelease.pas',
+  DeleteAndReleaseRange in 'Examples\DeleteAndReleaseRange.pas',
+  DeleteRange in 'Examples\DeleteRange.pas',
+  Equal in 'Examples\Equal.pas',
+  EqualStart in 'Examples\EqualStart.pas',
+  Every in 'Examples\Every.pas',
+  FindAll in 'Examples\FindAll.pas',
+  FindAllIndices in 'Examples\FindAllIndices.pas',
+  FindDef in 'Examples\FindDef.pas',
+  FindIndex in 'Examples\FindIndex.pas',
+  FindLastDef in 'Examples\FindLastDef.pas',
+  FindLastIndex in 'Examples\FindLastIndex.pas',
+  First in 'Examples\First.pas',
+  ForEach in 'Examples\ForEach.pas',
+  IndexOf in 'Examples\IndexOf.pas',
+  IndicesOf in 'Examples\IndicesOf.pas',
+  Insert in 'Examples\Insert.pas',
+  Last in 'Examples\Last.pas',
+  LastIndexOf in 'Examples\LastIndexOf.pas',
+  Max in 'Examples\Max.pas',
+  Min in 'Examples\Min.pas',
+  MinMax in 'Examples\MinMax.pas',
+  OccurrencesOf in 'Examples\OccurrencesOf.pas',
+  Pick in 'Examples\Pick.pas',
+  Pop in 'Examples\Pop.pas',
+  PopAndFree in 'Examples\PopAndFree.pas',
+  PopAndRelease in 'Examples\PopAndRelease.pas',
+  Push in 'Examples\Push.pas',
+  Reduce in 'Examples\Reduce.pas',
+  Reverse in 'Examples\Reverse.pas',
+  Shift in 'Examples\Shift.pas',
+  ShiftAndFree in 'Examples\ShiftAndFree.pas',
+  ShiftAndRelease in 'Examples\ShiftAndRelease.pas',
+  Slice in 'Examples\Slice.pas',
+  Some in 'Examples\Some.pas',
+  Sort in 'Examples\Sort.pas',
+  Transform in 'Examples\Transform.pas',
+  TryFind in 'Examples\TryFind.pas',
+  TryFindLast in 'Examples\TryFindLast.pas',
+  UnShift in 'Examples\UnShift.pas';
+
+var
+  MethodName: string;
+  MethodTitle: string;
+  ProcInfo: TProcedureInfo;
+  ProcTitle: string;
+
+begin
+  ReportMemoryLeaksOnShutdown := True;
+  try
+    for MethodName in TRegistrar.MethodNames do
+    begin
+      MethodTitle := 'TArrayUtils.' + MethodName;
+      Writeln(MethodTitle);
+      Writeln(StringOfChar('=', Length(MethodTitle)));
+      Writeln;
+      for ProcInfo in TRegistrar.GetProcs(MethodName) do
+      begin
+        ProcTitle := 'Running ' + ProcInfo.Name;
+        Writeln(ProcTitle);
+        Writeln(StringOfChar('-', Length(ProcTitle)));
+        Writeln;
+        // Call procedure
+        ProcInfo.Proc;
+        Writeln('DONE');
+        Writeln;
+      end;
+    end;
+  except
+    on E: Exception do
+      Writeln(E.ClassName, ': ', E.Message);
+  end;
+  Writeln;
+  Writeln('END OF DEMO: press enter to exit');
+  Readln;
+end.

Demos/ArrayUtilsDemo.dproj

@@ -0,0 +1,82 @@
+{
+ * Example code for TArrayUtils.Chop<T>.
+ *
+ * Contains copies the example code included in the Array Utilities Unit
+ * documentation at https://delphidabbler.com/url/arrayutils-docs.
+ *
+ * Any copyright in this file is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+}
+
+unit Chop;
+
+interface
+
+implementation
+
+uses
+  SysUtils,
+  Generics.Defaults,
+  DelphiDabbler.Lib.ArrayUtils,
+  Registrar;
+
+procedure Chop_Eg1;
+var
+  A, ATest, ASlice, AExpectedSlice, AExpectedRemainder: TArray<string>;
+begin
+  A := TArray<string>.Create('a', 'stitch', 'in', 'time', 'saves', 'nine');
+  // slice from the start of A
+  ATest := Copy(A);
+  ASlice := TArrayUtils.Chop<string>(ATest, 0, 2);
+  AExpectedRemainder := TArray<string>.Create('time', 'saves', 'nine');
+  AExpectedSlice := TArray<string>.Create('a', 'stitch', 'in');
+  Assert(TArrayUtils.Equal<string>(AExpectedRemainder, ATest, SameStr));
+  Assert(TArrayUtils.Equal<string>(AExpectedSlice, ASlice, SameStr));
+  // Chop in the middle of ATest
+  ATest := Copy(A);
+  ASlice := TArrayUtils.Chop<string>(ATest, 2, 4);
+  AExpectedRemainder := TArray<string>.Create('a', 'stitch', 'nine');
+  AExpectedSlice := TArray<string>.Create('in', 'time', 'saves');
+  Assert(TArrayUtils.Equal<string>(AExpectedRemainder, ATest, SameStr));
+  Assert(TArrayUtils.Equal<string>(AExpectedSlice, ASlice, SameStr));
+  // Chop at the end of ATest
+  ATest := Copy(A);
+  ASlice := TArrayUtils.Chop<string>(ATest, 4, 5);
+  AExpectedRemainder := TArray<string>.Create('a', 'stitch', 'in', 'time');
+  AExpectedSlice := TArray<string>.Create('saves', 'nine');
+  Assert(TArrayUtils.Equal<string>(AExpectedRemainder, ATest, SameStr));
+  Assert(TArrayUtils.Equal<string>(AExpectedSlice, ASlice, SameStr));
+end;
+
+procedure Chop_Eg2;
+var
+  A, ATest, ASlice, AExpectedSlice, AExpectedRemainder: TArray<string>;
+begin
+  A := TArray<string>.Create('a', 'stitch', 'in', 'time', 'saves', 'nine');
+  // slice from mid to end of A
+  ATest := Copy(A);
+  ASlice := TArrayUtils.Chop<string>(ATest, 3);
+  AExpectedRemainder := TArray<string>.Create('a', 'stitch', 'in');
+  AExpectedSlice := TArray<string>.Create('time', 'saves', 'nine');
+  Assert(TArrayUtils.Equal<string>(AExpectedRemainder, ATest, SameStr));
+  Assert(TArrayUtils.Equal<string>(AExpectedSlice, ASlice, SameStr));
+  // Chop of all of ATest
+  ATest := Copy(A);
+  ASlice := TArrayUtils.Chop<string>(ATest, 0);
+  AExpectedRemainder := TArray<string>.Create();
+  AExpectedSlice := Copy(A);
+  Assert(TArrayUtils.Equal<string>(AExpectedRemainder, ATest, SameStr));
+  Assert(TArrayUtils.Equal<string>(AExpectedSlice, ASlice, SameStr));
+end;
+
+initialization
+
+TRegistrar.Add(
+  'Chop<T>',
+  TArray<TProcedureInfo>.Create(
+    TProcedureInfo.Create('Chop_Eg1', @Chop_Eg1),
+    TProcedureInfo.Create('Chop_Eg2', @Chop_Eg2)
+  )
+);
+
+end.

Demos/Examples/Chop.pas

@@ -0,0 +1,70 @@
+{
+ * Example code for TArrayUtils.Compare<T>.
+ *
+ * Contains copies the example code included in the Array Utilities Unit
+ * documentation at https://delphidabbler.com/url/arrayutils-docs.
+ *
+ * Any copyright in this file is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+}
+
+unit Compare;
+
+interface
+
+implementation
+
+uses
+  SysUtils,
+  Generics.Defaults,
+  DelphiDabbler.Lib.ArrayUtils,
+  Registrar;
+
+procedure Compare_Eg1;
+var
+  A, B, C, D, E: TArray<Integer>;
+  ComparerFn: TComparison<Integer>;
+begin
+  A := TArray<Integer>.Create(1, 2, 3);
+  B := TArray<Integer>.Create(1, 2, 3);
+  C := TArray<Integer>.Create(1, 2);
+  D := TArray<Integer>.Create(1, 5, 7);
+  E := TArray<Integer>.Create();        // empty
+  ComparerFn := function(const Left, Right: Integer): Integer
+    begin
+      Result := Left - Right;
+    end;
+  Assert(TArrayUtils.Compare<Integer>(A, B, ComparerFn) = 0);
+  Assert(TArrayUtils.Compare<Integer>(A, C, ComparerFn) > 0);
+  Assert(TArrayUtils.Compare<Integer>(A, D, ComparerFn) < 0);
+  Assert(TArrayUtils.Compare<Integer>(A, E, ComparerFn) > 0);
+end;
+
+procedure Compare_Eg2;
+var
+  A, B, C, D, E: TArray<string>;
+  ComparerObj: IComparer<string>;
+begin
+  A := TArray<string>.Create('a', 'b', 'c');
+  B := TArray<string>.Create('a', 'b', 'c');
+  C := TArray<string>.Create('a', 'b');
+  D := TArray<string>.Create('a', 'd', 'f');
+  E := TArray<string>.Create();        // empty
+  ComparerObj := TDelegatedComparer<string>.Create(CompareStr);
+  Assert(TArrayUtils.Compare<string>(A, B, ComparerObj) = 0);
+  Assert(TArrayUtils.Compare<string>(A, C, ComparerObj) > 0);
+  Assert(TArrayUtils.Compare<string>(A, D, ComparerObj) < 0);
+  Assert(TArrayUtils.Compare<string>(A, E, ComparerObj) > 0);
+end;
+
+initialization
+
+TRegistrar.Add(
+  'Compare<T>',
+  TArray<TProcedureInfo>.Create(
+    TProcedureInfo.Create('Compare_Eg1', @Compare_Eg1),
+    TProcedureInfo.Create('Compare_Eg2', @Compare_Eg2)
+  )
+);
+
+end.

Demos/Examples/Compare.pas

@@ -0,0 +1,41 @@
+{
+ * Example code for TArrayUtils.Concat<T>.
+ *
+ * Contains copies the example code included in the Array Utilities Unit
+ * documentation at https://delphidabbler.com/url/arrayutils-docs.
+ *
+ * Any copyright in this file is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+}
+
+unit Concat;
+
+interface
+
+implementation
+
+uses
+  DelphiDabbler.Lib.ArrayUtils,
+  Registrar;
+
+procedure Concat_Eg;
+var
+  A, B, Got, Expected: TArray<Integer>;
+begin
+  A := TArray<Integer>.Create(1, 2, 3, 4);
+  B := TArray<Integer>.Create(42, 56);
+  Got := TArrayUtils.Concat<Integer>(A, B);
+  Expected := TArray<Integer>.Create(1, 2, 3, 4, 42, 56);
+  Assert(TArrayUtils.Equal<Integer>(Expected, Got));
+end;
+
+initialization
+
+TRegistrar.Add(
+  'Concat<T>',
+  TArray<TProcedureInfo>.Create(
+    TProcedureInfo.Create('Concat_Eg', @Concat_Eg)
+  )
+);
+
+end.

Demos/Examples/Concat.pas

@@ -0,0 +1,65 @@
+{
+ * Example code for TArrayUtils.Contains<T>.
+ *
+ * Contains copies the example code included in the Array Utilities Unit
+ * documentation at https://delphidabbler.com/url/arrayutils-docs.
+ *
+ * Any copyright in this file is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+}
+
+unit Contains;
+
+interface
+
+implementation
+
+uses
+  SysUtils,
+  Generics.Defaults,
+  DelphiDabbler.Lib.ArrayUtils,
+  Registrar;
+
+procedure Contains_Eg1;
+var
+  A: TArray<Integer>;
+  EqComparerFn: TEqualityComparison<Integer>;
+begin
+  A := TArray<Integer>.Create(1, 2, 3);
+  EqComparerFn := function(const Left, Right: Integer): Boolean
+    begin
+      Result := Left = Right;
+    end;
+  Assert(TArrayUtils.Contains<Integer>(2, A, EqComparerFn) = True);
+  Assert(TArrayUtils.Contains<Integer>(4, A, EqComparerFn) = False);
+end;
+
+procedure Contains_Eg2;
+var
+  A: TArray<string>;
+  EqComparerObj: IEqualityComparer<string>;
+begin
+  A := TArray<string>.Create('a', 'b', 'c');
+  EqComparerObj := TDelegatedEqualityComparer<string>.Create(
+    SameStr,
+    function(const Value: string): Integer
+    begin
+      // only do this if you KNOW the hash function won't be called
+      Result := 0;
+    end
+  );
+  Assert(TArrayUtils.Contains<string>('b', A, EqComparerObj) = True);
+  Assert(TArrayUtils.Contains<string>('d', A, EqComparerObj) = False);
+end;
+
+initialization
+
+TRegistrar.Add(
+  'Contains<T>',
+  TArray<TProcedureInfo>.Create(
+    TProcedureInfo.Create('Contains_Eg1', @Contains_Eg1),
+    TProcedureInfo.Create('Contains_Eg2', @Contains_Eg2)
+  )
+);
+
+end.