removed unnecessary constructor overloads

Author: sglienke

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

@@ -72,9 +72,7 @@   TEnumerableBase<T> = class abstract(TEnumerableBase)
     function UseComparer(typeKind: TTypeKind): Boolean; inline;
     property Comparer: IComparer<T> read fComparer;
   public
-    constructor Create; overload; virtual;
-    constructor Create(const comparer: IComparer<T>); overload;
-    constructor Create(const comparer: TComparison<T>); overload;
+    constructor Create;
 
     function Aggregate(const func: Func<T, T, T>): T;
 
@@ -349,7 +347,7 @@   TIterator<T> = class abstract(TEnumerableBase<T>, IEnumerator<T>)
     procedure Start; virtual;
     function TryMoveNext(var current: T): Boolean; virtual; abstract;
   public
-    constructor Create; override;
+    constructor Create;
     function GetEnumerator: IEnumerator<T>;
     function MoveNext: Boolean;
   end;
@@ -392,7 +390,7 @@   TCollectionBase<T> = class abstract(TEnumerableBase<T>)
     property OnChanged: TCollectionChangedEventImpl<T> read fOnChanged;
     property Notify: TNotify read fNotify;
   public
-    constructor Create; override;
+    constructor Create;
     destructor Destroy; override;
 
     procedure AddRange(const values: array of T); overload;
@@ -527,9 +525,7 @@       TEnumerator = class(TRefCountedObject, IEnumerator<T>)
     property Tail: PT read GetTail;
     property OwnsObjects: Boolean read GetOwnsObjects;
   public
-    constructor Create; override;
-    constructor Create(capacity: Integer; ownsObjects: Boolean = False); overload;
-    constructor Create(ownsObjects: Boolean); overload;
+    constructor Create(capacity: Integer = 0; ownsObjects: Boolean = False);
     destructor Destroy; override;
 
   {$REGION 'Implements IEnumerable<T>'}
@@ -564,7 +560,7 @@   TMapBase<TKey, T> = class abstract(TCollectionBase<TPair<TKey, T>>)
     procedure KeyChanged(const item: TKey; action: TCollectionChangedAction); inline;
     procedure ValueChanged(const item: T; action: TCollectionChangedAction); inline;
   public
-    constructor Create; override;
+    constructor Create;
     destructor Destroy; override;
 
     function Add(const item: TKeyValuePair): Boolean; overload;
@@ -839,18 +835,6 @@ constructor TEnumerableBase<T>.Create;
     fComparer := IComparer<T>(_LookupVtableInfo(giComparer, GetElementType, SizeOf(T)));
 end;
 
-constructor TEnumerableBase<T>.Create(const comparer: IComparer<T>);
-begin
-  Create;
-  if Assigned(comparer) then
-    fComparer := comparer;
-end;
-
-constructor TEnumerableBase<T>.Create(const comparer: TComparison<T>);
-begin
-  Create(IComparer<T>(PPointer(@comparer)^));
-end;
-
 function TEnumerableBase<T>.UseComparer(typeKind: TTypeKind): Boolean;
 const
   FastComparableTypes = [tkUnknown, tkInteger, tkChar, tkEnumeration, tkSet,
@@ -1813,8 +1797,9 @@ procedure TIterator<T>.Start;
 
 constructor TSourceIterator<T>.Create(const source: IEnumerable<T>);
 begin
+  fComparer := source.Comparer;
   fSource := source;
-  inherited Create(fSource.Comparer);
+  inherited Create;
 end;
 
 function TSourceIterator<T>.GetElementType: PTypeInfo;
@@ -2057,10 +2042,10 @@ constructor TInnerCollection<T>.Create(const source: TRefCountedObject;
   hashTable: PHashTable; elementType: PTypeInfo;
   const comparer: IEqualityComparer<T>; offset: Integer);
 begin
-  inherited Create(IComparer<T>(_LookupVtableInfo(giComparer, elementType, SizeOf(T))));
+  fElementType := elementType;
+  inherited Create;
   fSource := source;
   fHashTable := hashTable;
-  fElementType := elementType;
   fComparer := comparer;
   fOffset := THashTable.KeyOffset + offset;
 end;
@@ -2240,25 +2225,14 @@ function THashTableEnumerator.MoveNext: Boolean;
 
 {$REGION 'TCircularArrayBuffer<T>'}
 
-constructor TCircularArrayBuffer<T>.Create;
+constructor TCircularArrayBuffer<T>.Create(capacity: Integer; ownsObjects: Boolean);
 begin
   inherited Create;
   fOnChanged := TCollectionChangedEventImpl<T>.Create;
-end;
-
-constructor TCircularArrayBuffer<T>.Create(capacity: Integer; ownsObjects: Boolean);
-begin
-  Create;
   SetCapacity(capacity);
   SetOwnsObjects(ownsObjects);
 end;
 
-constructor TCircularArrayBuffer<T>.Create(ownsObjects: Boolean);
-begin
-  Create;
-  SetOwnsObjects(ownsObjects);
-end;
-
 destructor TCircularArrayBuffer<T>.Destroy;
 begin
   Clear;
@@ -2823,7 +2797,8 @@ constructor TIteratorBase<T>.Create(const source: IEnumerable<T>;
   StartFuncs: array[TIteratorKind] of Pointer;
 begin
   fIterator.Source := source;
-  inherited Create(source.Comparer);
+  fComparer := source.Comparer;
+  inherited Create;
   fIterator.TypeInfo := TypeInfo(TIteratorRec<T>);
   fIterator.Count := count;
   fIterator.Predicate := IInterface(predicate);

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

@@ -100,7 +100,6 @@       TEnumerator = class(THashTableEnumerator, IEnumerator<TKeyValuePair>)
       const keyComparer: IEqualityComparer<TKey>;
       const valueComparer: IEqualityComparer<TValue>;
       ownerships: TDictionaryOwnerships);
-
     destructor Destroy; override;
 
   {$REGION 'Implements IEnumerable<TPair<TKey, TValue>>'}
@@ -507,8 +506,8 @@       TValueCollection = class(TEnumerableBase<TValue>,
     function DoMoveNext(var currentNode: PNode; var finished: Boolean;
       iteratorVersion: Integer): Boolean;
   public
-    constructor Create; override;
-    constructor Create(const keyComparer: IComparer<TKey>; const valueComparer: IEqualityComparer<TValue>); overload;
+    constructor Create(const keyComparer: IComparer<TKey>;
+      const valueComparer: IEqualityComparer<TValue>);
     destructor Destroy; override;
 
   {$REGION 'Implements IEnumerable<TPair<TKey, TValue>>'}
@@ -615,8 +614,8 @@ constructor TDictionary<TKey, TValue>.Create(capacity: Integer;
     if ValueType.Kind <> tkClass then
       raise Error.NoClassType(ValueType);
 
-  inherited Create();
   fComparer := TComparer.Create(nil);
+  inherited Create;
   fOwnerships := ownerships;
   if Assigned(keyComparer) then
     fKeyComparer := keyComparer
@@ -2305,15 +2304,11 @@ function TBidiDictionary<TKey, TValue>.TValueCollection._Release: Integer;
 
 {$REGION 'TSortedDictionary<TKey, TValue>'}
 
-constructor TSortedDictionary<TKey, TValue>.Create;
-begin
-  Create(nil, nil);
-end;
-
 constructor TSortedDictionary<TKey, TValue>.Create(
   const keyComparer: IComparer<TKey>;
   const valueComparer: IEqualityComparer<TValue>);
 begin
+  fComparer := TComparer.Create(nil);
   inherited Create;
 
   fKeys := TKeyCollection.Create(Self);
@@ -2324,7 +2319,6 @@ constructor TSortedDictionary<TKey, TValue>.Create(
     fKeyComparer := keyComparer
   else
     fKeyComparer := IComparer<TKey>(_LookupVtableInfo(giComparer, TypeInfo(TKey), SizeOf(TKey)));
-  fComparer := TComparer.Create(nil);
   if Assigned(valueComparer) then
     fValueComparer := valueComparer
   else

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

@@ -107,8 +107,7 @@       TEnumerator = class(TRefCountedObject, IEnumerator<T>)
     property Items[index: Integer]: T read GetItem write SetItem; default;
     property OwnsObjects: Boolean read GetOwnsObjects;
   public
-    constructor Create(const values: array of T); overload;
-    constructor Create(const values: IEnumerable<T>); overload;
+    constructor Create(const comparer: IComparer<T>); overload;
     destructor Destroy; override;
 
   {$REGION 'Implements IEnumerable<T>'}
@@ -381,37 +380,10 @@ implementation
 
 {$REGION 'TAbstractArrayList<T>'}
 
-constructor TAbstractArrayList<T>.Create(const values: array of T);
-var
-  count, i: Integer;
+constructor TAbstractArrayList<T>.Create(const comparer: IComparer<T>);
 begin
-  Create;
-  count := Length(values);
-  if count > 0 then
-  begin
-    SetCount(count);
-    for i := Low(values) to High(values) do
-      fItems[i] := values[i];
-  end;
-end;
-
-constructor TAbstractArrayList<T>.Create(const values: IEnumerable<T>);
-var
-  collection: IReadOnlyCollection<T>;
-  count: Integer;
-begin
-  Create;
-  if Supports(values, IReadOnlyCollection<T>, collection) then
-  begin
-    count := collection.Count;
-    if count > 0 then
-    begin
-      SetCount(count);
-      collection.CopyTo(fItems, 0);
-    end;
-  end
-  else
-    AddRange(values);
+  fComparer := comparer;
+  inherited Create;
 end;
 
 destructor TAbstractArrayList<T>.Destroy;
@@ -462,10 +434,7 @@ procedure TAbstractArrayList<T>.AddRange(const values: IEnumerable<T>);
 
 function TAbstractArrayList<T>.GetEnumerator: IEnumerator<T>;
 begin
-  if TType.Kind<T> = tkClass then
-    IEnumerator<TObject>(Result) := TList<TObject>.TEnumerator.Create(TList<TObject>(Self))
-  else
-    Result := TEnumerator.Create(Self);
+  Result := TEnumerator.Create(Self);
 end;
 
 function TAbstractArrayList<T>.GetIsEmpty: Boolean;
@@ -2020,7 +1989,8 @@ constructor TFoldedSortedList<T>.Create(elementType: PTypeInfo;
   const comparer: IComparer<T>; ownsObjects: Boolean);
 begin
   fElementType := elementType;
-  inherited Create(comparer);
+  fComparer := comparer;
+  inherited Create;
   SetOwnsObjects(ownsObjects);
 end;
 

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

@@ -145,8 +145,7 @@       TEntryEnumerator = class(TRefCountedObject, IEnumerator<TEntry>)
   protected
     function CreateMultiSet: IMultiSet<T>; override;
   public
-    constructor Create; override;
-    constructor Create(const comparer: IEqualityComparer<T>); overload;
+    constructor Create(const comparer: IEqualityComparer<T>);
     destructor Destroy; override;
 
   {$REGION 'Implements IEnumerable<T>'}
@@ -283,8 +282,7 @@       TEntryEnumerator = class(TRefCountedObject, IEnumerator<TEntry>)
   protected
     function CreateMultiSet: IMultiSet<T>; override;
   public
-    constructor Create; override;
-    constructor Create(const comparer: IComparer<T>); overload;
+    constructor Create(const comparer: IComparer<T>);
     destructor Destroy; override;
 
   {$REGION 'Implements IEnumerable<T>'}
@@ -351,7 +349,7 @@ function TAbstractMultiSet<T>.OrderedByCount: IReadOnlyMultiSet<T>;
       else
         Result := 1;
     end);
-  localSet := THashMultiSet<T>.Create;
+  localSet := THashMultiSet<T>.Create(nil);
   for i := 0 to High(items) do
     localSet.Add(items[i].Value.Item, items[i].Value.Count);
   Result := localSet as IReadOnlyMultiSet<T>;
@@ -382,11 +380,6 @@ function TAbstractMultiSet<T>.SetEquals(const other: IEnumerable<T>): Boolean;
 
 {$REGION 'THashMultiSet<T>'}
 
-constructor THashMultiSet<T>.Create;
-begin
-  Create(nil);
-end;
-
 constructor THashMultiSet<T>.Create(const comparer: IEqualityComparer<T>);
 begin
   inherited Create;
@@ -785,11 +778,6 @@ function THashMultiSet<T>.TEntryEnumerator.MoveNext: Boolean;
 
 {$REGION 'TTreeMultiSet<T>'}
 
-constructor TTreeMultiSet<T>.Create;
-begin
-  Create(nil);
-end;
-
 constructor TTreeMultiSet<T>.Create(const comparer: IComparer<T>);
 begin
   inherited Create;

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

@@ -252,10 +252,9 @@ constructor TQueue<T>.Create(const values: array of T);
 var
   i: Integer;
 begin
-  inherited Create;
-  SetCapacity(Length(values));
+  inherited Create(Length(values));
   for i := 0 to High(values) do
-    AddToTail(values[i]);
+    Enqueue(values[i]);
 end;
 
 constructor TQueue<T>.Create(const values: IEnumerable<T>);
@@ -432,18 +431,18 @@ constructor TDeque<T>.Create(const values: array of T);
 var
   i: Integer;
 begin
-  Create;
+  inherited Create;
   SetCapacity(Length(values));
-  for i := Low(values) to High(values) do
-    AddToTail(values[i]);
+  for i := 0 to High(values) do
+    AddLast(values[i]);
 end;
 
 constructor TDeque<T>.Create(const values: IEnumerable<T>);
 var
   enumerator: IEnumerator<T>;
   item: T;
 begin
-  Create;
+  inherited Create;
   enumerator := values.GetEnumerator;
   while enumerator.MoveNext do
   begin
@@ -523,8 +522,9 @@ function TEvictingDeque<T>.AddLast(const item: T): Boolean;
 constructor TFoldedQueue<T>.Create(const elementType: PTypeInfo;
   const comparer: IComparer<T>; ownsObjects: Boolean);
 begin
-  inherited Create(comparer);
   fElementType := elementType;
+  fComparer := comparer;
+  inherited Create;
   SetOwnsObjects(ownsObjects);
 end;