void UpdateInstalledPackages()
{
sortedInstalledPackages = installedPackages
.OrderBy(p => p.Identity.Id)
.ToImmutableArray();
MainThread.Post(() => NotifyPropertyChanged(nameof(InstalledPackages)));
}
private int GetHashCodeCore()
{
var hash = new HashCode();
hash.Add(Name);
foreach (var w in _words.OrderBy(w => w.Spelling))
{
hash.Add(w);
}
return(hash.ToHashCode());
}
public CacheKey(
ImmutableHashSet <Assembly> assemblies,
ImmutableHashSet <Type> parts,
ImmutableHashSet <Type> excludedPartTypes
)
{
_assemblies = assemblies
.OrderBy((a, b) => string.CompareOrdinal(a.FullName, b.FullName))
.ToImmutableArray();
_parts = parts
.OrderBy((a, b) => string.CompareOrdinal(a.FullName, b.FullName))
.ToImmutableArray();
_excludedPartTypes = excludedPartTypes
.OrderBy((a, b) => string.CompareOrdinal(a.FullName, b.FullName))
.ToImmutableArray();
}
private void OnTimer()
{
// Check if the number of desired connections is already enough
if (ConnectedPeers.Count >= MinDesiredConnections)
{
return;
}
// If there aren't available UnconnectedPeers, it triggers an abstract implementation of NeedMorePeers
if (UnconnectedPeers.Count == 0)
{
NeedMorePeers(MinDesiredConnections - ConnectedPeers.Count);
}
Random rand = new Random();
IPEndPoint[] endpoints = UnconnectedPeers.OrderBy(u => rand.Next()).Take(MinDesiredConnections - ConnectedPeers.Count).ToArray();
ImmutableInterlocked.Update(ref UnconnectedPeers, p => p.Except(endpoints));
foreach (IPEndPoint endpoint in endpoints)
{
ConnectToPeer(endpoint);
}
}
public CacheKey(ImmutableHashSet <Assembly> assemblies, ImmutableHashSet <Type> parts, ImmutableHashSet <Type> excludedPartTypes)
{
_assemblies = assemblies.OrderBy(a => a.FullName, StringComparer.Ordinal).ToImmutableArray();
_parts = parts.OrderBy(a => a.FullName, StringComparer.Ordinal).ToImmutableArray();
_excludedPartTypes = excludedPartTypes.OrderBy(a => a.FullName, StringComparer.Ordinal).ToImmutableArray();
}
public static ImmutableArray <string> Fuzzy(
string value,
SpellingData spellingData,
CancellationToken cancellationToken = default)
{
int length = value.Length;
if (length <= 3)
{
return(ImmutableArray <string> .Empty);
}
ImmutableHashSet <string> .Builder matches = null;
WordCharMap map = spellingData.CharIndexMap;
WordCharMap reversedMap = spellingData.ReversedCharIndexMap;
var intersects = new ImmutableHashSet <string> [length];
int i = 0;
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
if (!map.TryGetValue(value, i, out ImmutableHashSet <string> values))
{
break;
}
ImmutableHashSet <string> intersect = (i == 0)
? values
: intersects[i - 1].Intersect(values);
if (i == length - 2)
{
TryAddMatches(intersect, length, ref matches);
}
else if (i == length - 1)
{
TryAddMatches(intersect, length + 1, ref matches);
break;
}
if (intersect.Count == 0)
{
break;
}
intersects[i] = intersect;
i++;
}
int j = length - 1;
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
if (!reversedMap.TryGetValue(value[j], length - j - 1, out ImmutableHashSet <string> values))
{
break;
}
ImmutableHashSet <string> intersect = (j == length - 1)
? values
: values.Intersect(intersects[j + 1]);
if (j == 1)
{
TryAddMatches(intersect, length, ref matches);
}
else if (j == 0)
{
TryAddMatches(intersect, length + 1, ref matches);
break;
}
if (intersect.Count == 0)
{
break;
}
int diff = j - i;
if (diff <= 0)
{
if (TryAddMatches(intersects[j - 1].Intersect(intersect), length + 1, ref matches))
{
break;
}
}
else if (diff == 1 &&
j > 1)
{
if (TryAddMatches(intersects[j - 2].Intersect(intersect), length - 1, length, ref matches))
{
break;
}
}
intersects[j] = intersect;
j--;
}
if (matches == null)
{
return(ImmutableArray <string> .Empty);
}
return(matches
.OrderBy(f => f)
.ToImmutableArray());
}
static UriSchemeLookup()
{
UriSchemeNamesSuffixed = UriSchemeNames.Select(u => $"{u}{UriSuffix}").ToImmutableHashSet();
UriSchemeNamesSuffixedOrdered = UriSchemeNamesSuffixed.OrderBy(usns => usns.Length).ThenBy(usns => usns).ToImmutableList();
}
public string GetDebugString()
{
// NOTE: keep this in sync with Serialize below.
using var _ = PooledStringBuilder.GetInstance(out var sb);
var(languages, values) = this.GetLanguagesAndValuesToSerialize(includeValues: true);
sb.AppendLine($"languages count: {languages.Count}");
foreach (var language in languages.Order())
{
Debug.Assert(RemoteSupportedLanguages.IsSupported(language));
sb.AppendLine(language);
}
sb.AppendLine();
sb.AppendLine($"values count: {values.Count}");
foreach (var(optionKey, (kind, value)) in values)
{
SerializeOptionKey(optionKey);
sb.Append($"{kind}: ");
if (kind == OptionValueKind.Enum)
{
RoslynDebug.Assert(value != null);
sb.AppendLine(value.ToString());
}
else if (kind is OptionValueKind.CodeStyleOption)
{
RoslynDebug.Assert(value != null);
var codeStyleOption = (ICodeStyleOption)value;
sb.AppendLine(codeStyleOption.ToXElement().ToString());
}
else if (kind is OptionValueKind.NamingStylePreferences)
{
RoslynDebug.Assert(value != null);
var namingStylePreferences = (NamingStylePreferences)value;
sb.AppendLine(namingStylePreferences.CreateXElement().ToString());
}
else
{
sb.AppendLine($"{value}");
}
sb.AppendLine();
}
sb.AppendLine();
sb.AppendLine($"changed options count: {_changedOptionKeysSerializable.Count}");
foreach (var changedKey in _changedOptionKeysSerializable.OrderBy(OptionKeyComparer.Instance))
{
SerializeOptionKey(changedKey);
}
return(sb.ToString());
void SerializeOptionKey(OptionKey optionKey)
{
Debug.Assert(ShouldSerialize(optionKey));
sb.AppendLine($"{optionKey.Option.Name} {optionKey.Option.Feature} {optionKey.Option.IsPerLanguage} {optionKey.Language}");
}
}
