improved case insensitive comparer

Author: sglienke

Source/Base/Collections/Spring.Collections.pas

@@ -3493,17 +3493,21 @@   TEnumerable = class
       const resultSelector: Func<TFirst, TSecond, TResult>): IEnumerable<TResult>; overload; static;
   end;
 
-  TStringComparer = class(TCustomComparer<string>)
+  TStringComparer = class(TObject, IComparer<string>, IEqualityComparer<string>)
   private
     fLocaleOptions: TLocaleOptions;
     fIgnoreCase: Boolean;
     class var
       fOrdinal: TStringComparer;
       fOrdinalIgnoreCase: TStringComparer;
   protected
-    function Compare(const Left, Right: string): Integer; override;
-    function Equals(const Left, Right: string): Boolean; override;
-    function GetHashCode(const Value: string): Integer; override;
+    function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
+    function _AddRef: Integer; stdcall;
+    function _Release: Integer; stdcall;
+
+    function Compare(const left, right: string): Integer; reintroduce;
+    function Equals(const left, right: string): Boolean; reintroduce;
+    function GetHashCode(const value: string): Integer; reintroduce;
   public
     constructor Create(localeOptions: TLocaleOptions; ignoreCase: Boolean);
     class constructor Create;
@@ -3553,9 +3557,6 @@ implementation
 
 uses
   Character,
-{$IFDEF DELPHIXE8_UP}
-  System.Hash,
-{$ENDIF}
   Rtti,
   Spring.Collections.Base,
   Spring.Collections.Dictionaries,
@@ -3567,6 +3568,7 @@ implementation
   Spring.Collections.Queues,
   Spring.Collections.Sets,
   Spring.Collections.Stacks,
+  Spring.Comparers,
   Spring.ResourceStrings;
 
 
@@ -7580,68 +7582,89 @@ constructor TStringComparer.Create(localeOptions: TLocaleOptions;
   FreeAndNil(fOrdinalIgnoreCase);
 end;
 
-function TStringComparer.Compare(const Left, Right: string): Integer;
-var
-  L, R: string;
+function TStringComparer.Compare(const left, right: string): Integer;
 begin
   if fIgnoreCase then
-  begin
-{$IFNDEF DELPHIXE4_UP}
-    L := TCharacter.ToUpper(Left);
-    R := TCharacter.ToUpper(Right);
-{$ELSE}
-    L := Char.ToUpper(Left);
-    R := Char.ToUpper(Right);
-{$ENDIF}
-  end else
-  begin
-    L := Left;
-    R := Right;
-  end;
-
-  Result := CompareStr(L, R, fLocaleOptions);
+    Result := AnsiCompareText(left, right)
+  else
+    Result := AnsiCompareStr(left, right);
 end;
 
-function TStringComparer.Equals(const Left, Right: string): Boolean;
-var
-  L, R: string;
+function TStringComparer.Equals(const left, right: string): Boolean;
 begin
   if fIgnoreCase then
+    Result := AnsiSameText(left, right)
+  else
+    Result := AnsiSameStr(left, right);
+end;
+
+function TStringComparer.GetHashCode(const value: string): Integer;
+const
+  FNV_Prime = 16777619;
+  FNV_OffsetBasis = Integer($811C9DC5); // 2166136261
+  NotAsciiMask = $FF80FF80;
+  LowerCaseMask = $00200020;
+
+  // for inlining when compiled as package - System.Length does not in that case
+  function Length(const s: string): NativeInt; inline;
   begin
-{$IFNDEF DELPHIXE4_UP}
-    L := TCharacter.ToUpper(Left);
-    R := TCharacter.ToUpper(Right);
-{$ELSE}
-    L := Char.ToUpper(Left);
-    R := Char.ToUpper(Right);
-{$ENDIF}
-  end else
-  begin
-    L := Left;
-    R := Right;
+    Result := IntPtr(s);
+    if Result <> 0 then
+      Result := PInteger(@PByte(Result)[-4])^;
   end;
 
-  Result := SameStr(L, R, fLocaleOptions);
-end;
+  function GetHashCodeIgnoreCaseSlow(const value: string): Integer;
+  var
+    s: string;
+    len, i: NativeInt;
+    c: Integer;
+  begin
+    s := AnsiUpperCase(value);
+    len := Length(s);
+    Result := FNV_OffsetBasis;
+    i := 0;
+    while len > 0 do
+    begin
+      c := PIntegerArray(s)[i];
+      c := c or LowerCaseMask;
+      Result := Result xor c;
+      {$Q-}
+      Result := Result * FNV_PRIME;
+      {$IFDEF OVERFLOWCHECKS_ON}{$Q+}{$ENDIF}
+      Inc(i);
+      Dec(len, 2);
+    end;
+  end;
 
-function TStringComparer.GetHashCode(const Value: string): Integer;
+label
+  NotAscii;
 var
-  s: string;
+  len, i: NativeInt;
+  hashCode, c: Integer;
 begin
+  len := Length(value);
   if fIgnoreCase then
-{$IFNDEF DELPHIXE4_UP}
-    S := TCharacter.ToUpper(Value)
-{$ELSE}
-    S := Char.ToUpper(Value)
-{$ENDIF}
+  begin
+    hashCode := FNV_OffsetBasis;
+    i := 0;
+    while len > 0 do
+    begin
+      c := PIntegerArray(value)[i];
+      if c and NotAsciiMask <> 0 then goto NotAscii;
+      c := c or LowerCaseMask;
+      hashCode := hashCode xor c;
+      {$Q-}
+      hashCode := hashCode * FNV_PRIME;
+      {$IFDEF OVERFLOWCHECKS_ON}{$Q+}{$ENDIF}
+      Inc(i);
+      Dec(len, 2);
+    end;
+    Exit(hashCode);
+  NotAscii:
+    Result := GetHashCodeIgnoreCaseSlow(value);
+  end
   else
-    S := Value;
-
-{$IFDEF DELPHIXE8_UP}
-  Result := THashBobJenkins.GetHashValue(S);
-{$ELSE}
-  Result := BobJenkinsHash(PChar(S)^, SizeOf(Char) * Length(S), 0);
-{$ENDIF}
+    Result := DefaultHashFunction(Pointer(value)^, len * SizeOf(Char));
 end;
 
 class function TStringComparer.Ordinal: TStringComparer;
@@ -7654,6 +7677,24 @@ class function TStringComparer.OrdinalIgnoreCase: TStringComparer;
   Result := fOrdinalIgnoreCase;
 end;
 
+function TStringComparer.QueryInterface(const IID: TGUID; out Obj): HResult;
+begin
+  if GetInterface(IID, Obj) then
+    Result := S_OK
+  else
+    Result := E_NOINTERFACE;
+end;
+
+function TStringComparer._AddRef: Integer;
+begin
+  Result := -1;
+end;
+
+function TStringComparer._Release: Integer;
+begin
+  Result := -1;
+end;
+
 {$ENDREGION}
 
 

Source/Base/Spring.Comparers.pas

@@ -823,10 +823,13 @@ function Equals_UString(const inst: Pointer; const left, right: string): Boolean
 {$ENDIF}
 
 function GetHashCode_UString(const inst: Pointer; const value: string): Integer;
+var
+  hashCode: NativeInt;
 begin
-  Result := NativeInt(value);
-  if Result <> 0 then
-    Result := DefaultHashFunction(PPointer(value)^, PInteger(PByte(value) - 4)^ * SizeOf(Char));
+  hashCode := NativeInt(value);
+  if hashCode <> 0 then
+    hashCode := DefaultHashFunction(PPointer(hashCode)^, PInteger(@PByte(value)[-4])^ * SizeOf(Char));
+  Result := hashCode;
 end;
 
 function Compare_Variant_Complex(checkEquality: Boolean; const left, right: PVariant): Integer;

Source/Base/Spring.HashTable.pas

@@ -589,8 +589,8 @@ function THashTable<T>.FindWithoutComparer(const key: T; options: Byte): Pointer
       end;
     tkUString:
     begin
-      hashCode := PNativeInt(@key)^;
-      if hashCode <> 0 then
+      hashCode := 0;
+      if PPointer(@key)^ <> nil then
       {$R-}
         hashCode := DefaultHashFunction(PPointer(@key)^^, PInteger(PByte((@key)^) - 4)^ * SizeOf(Char)) and not RemovedFlag;
       {$IFDEF RANGECHECKS_ON}{$R+}{$ENDIF}