int GetDecomposed(ref UnicodeEntry entry, int orgValue)
{
if (_compositeMap.TryGetValue(entry.CodeValue, out var comp))
{
if (!_compositeMap.ContainsKey(orgValue))
{
_compositeMap.Add(orgValue, comp);
}
return(1);
}
_decomposing.Clear();
_loader.AddDecomposing(entry.CodeValue, _decomposing, true);
_decomposeLetters.Clear();
foreach (var c in _decomposing)
{
if (_loader.TryGetEntry(c, out UnicodeEntry decomposed))
{
if (IsLetterOrDigit(decomposed.Category))
{
if (decomposed.Uppercase != 0)
{
if (!_loader.TryGetEntry(decomposed.Uppercase, out decomposed) ||
!IsLetterOrDigit(decomposed.Category))
{
continue;
}
}
_decomposeLetters.Add(decomposed);
}
}
}
switch (_decomposeLetters.Count)
{
case 0:
return(0);
case 1:
return(_decomposeLetters[0].CodeValue);
default:
_builder.Clear();
_decomposing.Clear();
foreach (var letter in _decomposeLetters)
{
_decomposing.Add(letter.CodeValue);
_builder.Append(' ').Append(letter.ToString());
}
_compositeMap.Add(entry.CodeValue, Add(_decomposing.ToArray()));
//Debug.WriteLine( $"{entry.Name} ({entry}) d[{_decomposeLetters.Count}]:{_builder.ToString()}" );
return(1);
}
}
public void BuildToUpperMap(bool text = false)
{
var map = new InterleaveMap();
foreach (KeyValuePair <int, int> pair in _iocMap)
{
if (!_iocMap.TryGetValue(pair.Value, out int key) ||
key != pair.Key)
{
Console.WriteLine("{0:X6} != {1:X6}", key, pair.Key);
}
else
{
UnicodeEntry left = _loader[pair.Key];
//var right = _loader[ pair.Value ];
if (left.Uppercase != 0)
{
if (left.Uppercase != pair.Value)
{
Console.WriteLine("{0:X6} != {1:X6}", key, pair.Key);
}
else
{
int diff = pair.Value ^ pair.Key;
map.Add((char)pair.Key, diff);
}
}
else if (left.LowerCase != pair.Value)
{
Console.WriteLine("{0:X6} != {1:X6}", key, pair.Key);
}
}
}
if (text)
{
using (var w = File.CreateText(@"../../bin/OrdinalIgnoreCaseMap.cs")) {
map.Write(w);
}
}
else
{
using (var w = File.Create(@"../../bin/OrdinalIgnoreCaseMap.bin"))
using (var b = new BinaryWriter(w)) {
map.Save(b);
}
}
}
public void TestHashCode()
{
for (var i = 0; i < _allStrings.Length; i++)
{
var str = _allStrings[i];
int hc = StringComparer.OrdinalIgnoreCase.GetHashCode(str);
int hc2 = OrdinalIgnoreCase.GetHashCode(str);
if (hc != hc2)
{
var points = _allPoints[i];
for (int j = 0; j < points.Length; j++)
{
UnicodeEntry cd = _loader[points[j]];
string str2 = cd.ToString();
hc = StringComparer.OrdinalIgnoreCase.GetHashCode(str2);
hc2 = OrdinalIgnoreCase.GetHashCode(str2);
if (hc != hc2)
{
if (cd.Uppercase != 0)
{
var cd2 = _loader[cd.Uppercase];
var str3 = cd2.ToString();
int hc3 = StringComparer.OrdinalIgnoreCase.GetHashCode(str3);
//int hc4 = MapUtil.GetCaseInsensitiveHashCode( str3 );
if (string.Equals(str2, str3, StringComparison.OrdinalIgnoreCase))
{
Debug.WriteLine("'{0}'", str2);
}
if (hc3 == hc)
{
Debug.WriteLine("'{0}' != '{1}' (U+{2:X6}) != U+{3:X6})" +
"(U+{4:X4},{5:X4}) != U+{6:X4},{7:X4})",
str2, str3, cd.CodeValue, cd2.CodeValue,
(int)str2[0], (int)str2[1], (int)str3[0], (int)str3[1]);
}
}
else
{
Debug.WriteLine("'{0}'", str2);
}
}
}
}
}
}
private void BuildCodeMap()
{
foreach (UcdBlock block in _loader.Blocks)
{
switch (block.Block)
{
case Block.HighSurrogates:
case Block.HighPrivateUseSurrogates:
case Block.LowSurrogates:
case Block.PrivateUseArea:
case Block.SupplementaryPrivateUseAreaA:
case Block.SupplementaryPrivateUseAreaB:
continue;
}
foreach (UnicodeEntry i in _loader.GetCodePoints(block))
{
if (i.CodeValue < 16)
{
_codeMap.Add((ushort)i.CodeValue, 0);
continue;
}
if (i.CodeValue == 'ὐ')
{
Debug.WriteLine("ὐ");
}
uint value = (uint)i.CodeValue;
UnicodeEntry entry = i;
if (entry.Uppercase != 0)
{
value = (uint)entry.Uppercase;
if (value > 0xFFFF)
{
continue;
}
if (!_loader.TryGetEntry(entry.Uppercase, out entry))
{
continue;
}
}
if (entry.DecomposingLength > 0)
{
//if ( entry.CodeValue == 0x321D ) {
// Debug.WriteLine( "Asdasd" );
//}
//SupportDecomposing(entry.Decomposing)
int control = GetDecomposed(ref entry, i.CodeValue);
if (control != 0)
{
//if ( !_loader.TryGetEntry( control, out entry ) || entry.CodeValue != control ) {
// continue;
//}
//value = (uint)entry.CodeValue;
value = (uint)control;
}
}
//if ( value > 0xFFFF || i.CodeValue > 0xffff ) {
// continue;
//}
if (value != i.CodeValue)
{
_codeMap.Add((ushort)i.CodeValue, (ushort)value);
}
//_list.Add( code );
}
}
}
