1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
/*============================================================
**
**
**
**
**
** Purpose: A collection of quick methods for comparing
** resource keys (strings)
**
**
===========================================================*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.Contracts;
namespace System.Resources
{
internal sealed class FastResourceComparer : IComparer, IEqualityComparer, IComparer<String>, IEqualityComparer<String>
{
internal static readonly FastResourceComparer Default = new FastResourceComparer();
// Implements IHashCodeProvider too, due to Hashtable requirements.
public int GetHashCode(Object key)
{
String s = (String)key;
return FastResourceComparer.HashFunction(s);
}
public int GetHashCode(String key)
{
return FastResourceComparer.HashFunction(key);
}
// This hash function MUST be publically documented with the resource
// file format, AND we may NEVER change this hash function's return
// value (without changing the file format).
internal static int HashFunction(String key)
{
// Never change this hash function. We must standardize it so that
// others can read & write our .resources files. Additionally, we
// have a copy of it in InternalResGen as well.
uint hash = 5381;
for (int i = 0; i < key.Length; i++)
hash = ((hash << 5) + hash) ^ key[i];
return (int)hash;
}
// Compares Strings quickly in a case-sensitive way
public int Compare(Object a, Object b)
{
if (a == b) return 0;
String sa = (String)a;
String sb = (String)b;
return String.CompareOrdinal(sa, sb);
}
public int Compare(String a, String b)
{
return String.CompareOrdinal(a, b);
}
public bool Equals(String a, String b)
{
return String.Equals(a, b);
}
public new bool Equals(Object a, Object b)
{
if (a == b) return true;
String sa = (String)a;
String sb = (String)b;
return String.Equals(sa, sb);
}
// Input is one string to compare with, and a byte[] containing chars in
// little endian unicode. Pass in the number of valid chars.
public unsafe static int CompareOrdinal(String a, byte[] bytes, int bCharLength)
{
Debug.Assert(a != null && bytes != null, "FastResourceComparer::CompareOrdinal must have non-null params");
Debug.Assert(bCharLength * 2 <= bytes.Length, "FastResourceComparer::CompareOrdinal - numChars is too big!");
// This is a managed version of strcmp, but I can't take advantage
// of a terminating 0, unlike strcmp in C.
int i = 0;
int r = 0;
// Compare the min length # of characters, then return length diffs.
int numChars = a.Length;
if (numChars > bCharLength)
numChars = bCharLength;
if (bCharLength == 0) // Can't use fixed on a 0-element array.
return (a.Length == 0) ? 0 : -1;
fixed (byte* pb = bytes)
{
byte* pChar = pb;
while (i < numChars && r == 0)
{
// little endian format
int b = pChar[0] | pChar[1] << 8;
r = a[i++] - b;
pChar += sizeof(char);
}
}
if (r != 0) return r;
return a.Length - bCharLength;
}
public static int CompareOrdinal(byte[] bytes, int aCharLength, String b)
{
return -CompareOrdinal(b, bytes, aCharLength);
}
// This method is to handle potentially misaligned data accesses.
// The byte* must point to little endian Unicode characters.
internal unsafe static int CompareOrdinal(byte* a, int byteLen, String b)
{
Debug.Assert((byteLen & 1) == 0, "CompareOrdinal is expecting a UTF-16 string length, which must be even!");
Debug.Assert(a != null && b != null, "Null args not allowed.");
Debug.Assert(byteLen >= 0, "byteLen must be non-negative.");
int r = 0;
int i = 0;
// Compare the min length # of characters, then return length diffs.
int numChars = byteLen >> 1;
if (numChars > b.Length)
numChars = b.Length;
while (i < numChars && r == 0)
{
// Must compare character by character, not byte by byte.
char aCh = (char)(*a++ | (*a++ << 8));
r = aCh - b[i++];
}
if (r != 0) return r;
return byteLen - b.Length * 2;
}
}
}
|
