/**
* Adds items to the "Volumes" field in the container configuration.
*
* @param volumes the directories to create volumes
* @return this
*/
public Builder AddVolumes(ISet <AbsoluteUnixPath> volumes)
{
if (volumes != null)
{
volumesBuilder.UnionWith(ImmutableHashSet.CreateRange(volumes));
}
return(this);
}
public void Overlaps()
{
var builder = ImmutableHashSet.CreateRange(Enumerable.Range(1, 3)).ToBuilder();
Assert.Throws <ArgumentNullException>("other", () => builder.Overlaps(null));
Assert.True(builder.Overlaps(Enumerable.Range(3, 2)));
Assert.False(builder.Overlaps(Enumerable.Range(4, 3)));
}
private object EntityStateFromBinary(byte[] binary)
{
using (var stream = new MemoryStream(binary, false))
{
var msg = EntityState.ParseFrom(stream);
return(new Shard.ShardState(ImmutableHashSet.CreateRange(msg.EntitiesList)));
}
}
public void IsProperSupersetOf()
{
var builder = ImmutableHashSet.CreateRange(Enumerable.Range(1, 3)).ToBuilder();
Assert.Throws <ArgumentNullException>(() => builder.IsProperSupersetOf(null));
Assert.False(builder.IsProperSupersetOf(Enumerable.Range(1, 3)));
Assert.True(builder.IsProperSupersetOf(Enumerable.Range(1, 2)));
}
public static IEnumerable <NuGetReference> FilterSearchResults(
string name,
IReadOnlyCollection <IPackageSearchMetadata> searchResults,
IEnumerable <TargetFrameworkMoniker> tfms,
NuGetVersion?currentVersion = null,
bool latestMinorAndBuildOnly = false)
{
if (searchResults is null || searchResults.Count == 0)
{
return(Enumerable.Empty <NuGetReference>());
}
var tfmSet = ImmutableHashSet.CreateRange(tfms.Select(t => NuGetFramework.Parse(t.Name)));
var results = searchResults
.Where(r => currentVersion is null || r.Identity.Version > currentVersion);
if (latestMinorAndBuildOnly)
{
results = results
.GroupBy(r => r.Identity.Version.Major)
.SelectMany(r =>
{
var max = r.Max(t => t.Identity.Version);
return(r.Where(t => t.Identity.Version == max));
});
}
return(results
.Where(r =>
{
// If the package has no dependency sets, then include it (as it may be build tools, analyzers, etc.).
if (!r.DependencySets.Any())
{
return true;
}
// If the package has dependency sets, only include it if there are dependency sets for each
// of the TFMs that need to be supported.
var unsupported = tfmSet;
foreach (var dep in r.DependencySets)
{
foreach (var t in unsupported)
{
if (DefaultCompatibilityProvider.Instance.IsCompatible(t, dep.TargetFramework))
{
unsupported = unsupported.Remove(t);
}
}
}
return unsupported.IsEmpty;
})
.Select(r => r.Identity.Version)
.OrderBy(v => v)
.Select(v => new NuGetReference(name, v.ToNormalizedString())));
}
public static async Task <List <(ISymbol, List <(SymbolUsageKind, ReferenceLocation)>)> > FindReferrersAsync(this ISymbol symbol, Project project, Predicate <ISymbol> definitionFilter = null, Predicate <SyntaxNode> nodeFilter = null, CancellationToken cancellationToken = default)
{
var docs = ImmutableHashSet.CreateRange(project.GetRelatedProjectDocuments());
var d = new Dictionary <ISymbol, List <(SymbolUsageKind, ReferenceLocation)> >(5);
// hack: fix FindReferencesAsync returning unbounded references for generic type or method
string sign = null;
Predicate <SymbolUsageKind> usageFilter = null;
switch (symbol.Kind)
{
case SymbolKind.NamedType:
if ((symbol as INamedTypeSymbol).IsBoundedGenericType())
{
sign = symbol.ToDisplayString();
}
break;
case SymbolKind.Method:
var m = symbol as IMethodSymbol;
if (m.IsBoundedGenericMethod())
{
sign = symbol.ToDisplayString();
// hack: in VS 2017 with Rosyln 2.10, we don't need this,
// but in VS 2019, we have to do that, otherwise we will get nothing
symbol = symbol.OriginalDefinition;
}
else if (m.IsExtensionMethod)
{
symbol = m.ReducedFrom ?? m;
}
else if (m.MethodKind == MethodKind.PropertyGet)
{
usageFilter = u => u != SymbolUsageKind.Write;
}
else if (m.MethodKind == MethodKind.PropertySet || m.IsInitOnly())
{
usageFilter = u => u == SymbolUsageKind.Write;
}
break;
}
foreach (var sr in await SymbolFinder.FindReferencesAsync(symbol, project.Solution, docs, cancellationToken).ConfigureAwait(false))
{
if (definitionFilter?.Invoke(sr.Definition) == false)
{
continue;
}
await GroupReferenceByContainerAsync(d, sr, sign, nodeFilter, usageFilter, cancellationToken).ConfigureAwait(false);
}
if (d.Count == 0)
{
return(null);
}
var r = new List <(ISymbol container, List <(SymbolUsageKind, ReferenceLocation)>)>(d.Count);
r.AddRange(d.Select(i => (i.Key, i.Value)));
r.Sort((x, y) => CompareSymbol(x.container, y.container));
return(r);
}
internal static async Task SearchForCubelights(Dictionary <uint, FileEntry> fileEntries, string outPath, IProgress <ProgressRecord> progress, CancellationToken ct)
{
var s = new System.Diagnostics.Stopwatch();
s.Start();
progress.Report(new ProgressRecord("Looking for worlds", 0, 0));
var levels = fileEntries.Values
.Where(fe => fe.PathIds.HasUnHashed)
.Where(fe => fe.ExtensionIds.ToString() == "world")
.Select(fe => fe.Parent.EntryPath)
.ToList();
var files = ImmutableHashSet.CreateRange(fileEntries.Select(i => i.Value.PathIds.Hashed));
var interestingPaths = new ConcurrentBag <string>();
var total = levels.Count;
var completed = 0;
var progressReporter = Task.Run(async() =>
{
while (completed < total && !ct.IsCancellationRequested)
{
await Task.Delay(100);
progress.Report(new ProgressRecord("Checking cubelight names", total, completed));
}
});
var opts = new ParallelOptions();
opts.CancellationToken = ct;
Parallel.ForEach(levels, levelname =>
{
for (var i = 1000; i <= 1000000; i++)
{
var path = $"{levelname}/cube_lights/{i}";
var hsh = Hash64.HashString(path);
if (files.Contains(hsh))
{
interestingPaths.Add(path);
}
}
var domeocc = $"{levelname}/cube_lights/dome_occlusion";
if (files.Contains(Hash64.HashString(domeocc)))
{
interestingPaths.Add(domeocc);
}
Interlocked.Increment(ref completed);
});
File.WriteAllLines(outPath, interestingPaths, new UTF8Encoding());
completed = total;
s.Stop();
Console.WriteLine("Bruteforced {1} combinations in {0} ms", s.ElapsedMilliseconds, total * 999000);
await progressReporter;
}
protected internal static ColumnSet GetColumns(Type type)
{
var cols = ReflectionExtensions.GetAttributes <DatabaseColumnAttribute>(type);
var columns = ImmutableHashSet.CreateRange(cols
.Select(col => new DatabaseColumnContext(col.Key.Name, col.Value)));
return(columns);
}
private static IReadOnlyCollection <INamedTypeSymbol> GetDisallowedCatchTypes(Compilation compilation)
{
return(ImmutableHashSet.CreateRange(
new[] {
WellKnownTypes.Object(compilation),
WellKnownTypes.Exception(compilation),
WellKnownTypes.SystemException(compilation)
}.Where(x => x != null)));
}
public void IsSubsetOf()
{
var builder = ImmutableHashSet.CreateRange(Enumerable.Range(1, 3)).ToBuilder();
AssertExtensions.Throws <ArgumentNullException>("other", () => builder.IsSubsetOf(null));
Assert.False(builder.IsSubsetOf(Enumerable.Range(1, 2)));
Assert.True(builder.IsSubsetOf(Enumerable.Range(1, 3)));
Assert.True(builder.IsSubsetOf(Enumerable.Range(1, 5)));
}
/// <summary>
/// TBD
/// </summary>
/// <returns>TBD</returns>
public Streams.Fusing.StructuralInfo ToInfo()
{
return(new Streams.Fusing.StructuralInfo(
ImmutableDictionary.CreateRange(Upstreams),
ImmutableDictionary.CreateRange(Downstreams),
ImmutableDictionary.CreateRange(InOwners),
ImmutableDictionary.CreateRange(OutOwners),
ImmutableHashSet.CreateRange(Modules)));
}
private static IReadOnlyCollection <INamedTypeSymbol> GetDisallowedCatchTypes(Compilation compilation)
{
return(ImmutableHashSet.CreateRange(
new[] {
compilation.GetSpecialType(SpecialType.System_Object),
compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemException),
compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemSystemException)
}.WhereNotNull()));
}
public void Notify(IReadOnlyCollection <ITile> changedTiles)
{
ImmutableHashSet <ITile> changedTilesSet = ImmutableHashSet.CreateRange(changedTiles);
//Possible user methods
try {
TileHeightsChangedCol?.Invoke(changedTiles);
}
catch (Exception e)
{
Urho.IO.Log.Write(LogLevel.Warning,
$"There was an unexpected exception during the invocation of {nameof(TileHeightsChangedCol)}: {e.Message}");
}
//Possible user methods
try {
TileHeightsChangedHash?.Invoke(changedTilesSet);
}
catch (Exception e)
{
Urho.IO.Log.Write(LogLevel.Warning,
$"There was an unexpected exception during the invocation of {nameof(TileHeightsChangedHash)}: {e.Message}");
}
foreach (var weakObserver in weakColObservers)
{
if (weakObserver.TryGetTarget(out var observer))
{
//Possible user methods
try {
observer.TileHeightsChanged(changedTiles);
}
catch (Exception e)
{
Urho.IO.Log.Write(LogLevel.Warning,
$"There was an unexpected exception during the invocation of {nameof(observer.TileHeightsChanged)}: {e.Message}");
}
}
}
foreach (var weakObserver in weakHashObservers)
{
if (weakObserver.TryGetTarget(out var observer))
{
//Possible user methods
try {
observer.TileHeightsChanged(changedTilesSet);
}
catch (Exception e) {
Urho.IO.Log.Write(LogLevel.Warning,
$"There was an unexpected exception during the invocation of {nameof(observer.TileHeightsChanged)}: {e.Message}");
}
}
}
}
/// <summary>
/// Creates a set of import constraints for an import site.
/// </summary>
/// <param name="importSite">The importing member or parameter.</param>
/// <returns>A set of import constraints.</returns>
private static ImmutableHashSet <IImportSatisfiabilityConstraint> GetImportConstraints(ICustomAttributeProvider importSite)
{
Requires.NotNull(importSite, nameof(importSite));
var constraints = ImmutableHashSet.CreateRange <IImportSatisfiabilityConstraint>(
from importConstraint in importSite.GetAttributes <ImportMetadataConstraintAttribute>()
select new ExportMetadataValueImportConstraint(importConstraint.Name, importConstraint.Value));
return(constraints);
}
public static void WritePrimitiveImmutableHashSetT()
{
ImmutableHashSet <int> input = ImmutableHashSet.CreateRange(new List <int> {
1, 2
});
string json = JsonSerializer.Serialize(input);
Assert.Equal("[1,2]", json);
}
public static void CreateAndRegisterActions(
CompilationStartAnalysisContext context,
AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer analyzer)
{
var attributeSetForMethodsToIgnore = ImmutableHashSet.CreateRange(GetAttributesForMethodsToIgnore(context.Compilation).WhereNotNull());
var eventsArgType = context.Compilation.EventArgsType();
var symbolAnalyzer = new SymbolStartAnalyzer(analyzer, eventsArgType, attributeSetForMethodsToIgnore);
context.RegisterSymbolStartAction(symbolAnalyzer.OnSymbolStart, SymbolKind.NamedType);
}
public async Task WritePrimitiveImmutableHashSetT()
{
ImmutableHashSet <int> input = ImmutableHashSet.CreateRange(new List <int> {
1, 2
});
string json = await Serializer.SerializeWrapper(input);
Assert.Equal("[1,2]", json);
}
public static Mock <ITargetedDependenciesSnapshot> ImplementMock(
string projectPath = null,
ITargetFramework targetFramework = null,
IEnumerable <IDependency> dependenciesWorld = null,
bool?hasUnresolvedDependency = null,
IProjectCatalogSnapshot catalogs = null,
IEnumerable <IDependency> topLevelDependencies = null,
bool?checkForUnresolvedDependencies = null,
MockBehavior?mockBehavior = null)
{
var behavior = mockBehavior ?? MockBehavior.Default;
var mock = new Mock <ITargetedDependenciesSnapshot>(behavior);
if (projectPath != null)
{
mock.Setup(x => x.ProjectPath).Returns(projectPath);
}
if (targetFramework != null)
{
mock.Setup(x => x.TargetFramework).Returns(targetFramework);
}
if (dependenciesWorld != null)
{
mock.Setup(x => x.DependenciesWorld)
.Returns(dependenciesWorld.ToImmutableDictionary(d => d.Id, StringComparer.OrdinalIgnoreCase));
}
if (hasUnresolvedDependency.HasValue)
{
mock.Setup(x => x.HasUnresolvedDependency).Returns(hasUnresolvedDependency.Value);
}
if (catalogs != null)
{
mock.Setup(x => x.Catalogs).Returns(catalogs);
}
if (topLevelDependencies != null)
{
Assert.True(topLevelDependencies.All(d => d.TopLevel));
mock.Setup(x => x.TopLevelDependencies)
.Returns(ImmutableHashSet.CreateRange(topLevelDependencies));
}
if (checkForUnresolvedDependencies.HasValue)
{
mock.Setup(x => x.CheckForUnresolvedDependencies(It.IsAny <string>())).Returns(checkForUnresolvedDependencies.Value);
mock.Setup(x => x.CheckForUnresolvedDependencies(It.IsAny <IDependency>())).Returns(checkForUnresolvedDependencies.Value);
}
return(mock);
}
internal static async Task SearchForStreams(Dictionary <uint, FileEntry> fileEntries, string outPath, IProgress <ProgressRecord> progress, CancellationToken ct)
{
var s = new System.Diagnostics.Stopwatch();
s.Start();
progress.Report(new ProgressRecord("Loading bank/stream names", 0, 0));
var pendingBankfile = File.ReadAllLinesAsync("Data/banknames", ct);
var pendingStreamfile = File.ReadAllLinesAsync("Data/streamnames", ct);
// It's immutable. Very threadsafe.
var files = ImmutableHashSet.CreateRange(fileEntries.Select(i => i.Value.PathIds.Hashed));
var interestingBanks = (await pendingBankfile)
.Where(i => files.Contains(Hash64.HashString(i)))
.Select(i => i.Split("/").Last())
.ToList();
var streamNames = await pendingStreamfile;
var interestingPaths = new ConcurrentBag <string>();
int completed = 0;
int total = streamNames.Length;
var progressReporter = Task.Run(async() =>
{
while (completed < total && !ct.IsCancellationRequested)
{
await Task.Delay(100);
progress.Report(new ProgressRecord("Checking stream names", total, completed));
}
});
var opts = new ParallelOptions();
opts.CancellationToken = ct;
Parallel.ForEach(streamNames, opts, (s) =>
{
for (var i = 0; i < interestingBanks.Count; i++)
{
var path = $"soundbanks/streamed/{interestingBanks[i]}/{s}";
var hsh = Hash64.HashString(path);
if (files.Contains(hsh))
{
interestingPaths.Add(path);
}
}
Interlocked.Increment(ref completed);
});
File.WriteAllLines(outPath, interestingPaths, new UTF8Encoding());
completed = total;
s.Stop();
Console.WriteLine("Bruteforced {1} combinations in {0} ms", s.ElapsedMilliseconds, total * interestingBanks.Count);
}
public void TestIfValidHash(string emailAddress)
{
var validCharacters = ImmutableHashSet.CreateRange("0987654321abcdef");
var gravatarHash = emailAddress.ToGravatarHash();
Assert.Equal(32, gravatarHash.Length);
for (var i = 0; i < gravatarHash.Length; i++)
{
Assert.Contains(gravatarHash[i], validCharacters);
}
}
internal static ProjectDependencyGraph ReadGraph(Solution solution, ObjectReader reader, CancellationToken cancellationToken)
{
var references = new List <ProjectId>();
var map = ImmutableDictionary.Create <ProjectId, ImmutableHashSet <ProjectId> >();
var reverseMap = ImmutableDictionary.Create <ProjectId, ImmutableHashSet <ProjectId> >();
var format = reader.ReadString();
if (!string.Equals(format, SerializationFormat, StringComparison.Ordinal))
{
return(null);
}
var graphVersion = VersionStamp.ReadFrom(reader);
var projectCount = reader.ReadInt32();
for (var i = 0; i < projectCount; i++)
{
cancellationToken.ThrowIfCancellationRequested();
var referenceCount = reader.ReadInt32();
if (referenceCount < 0)
{
continue;
}
references.Clear();
var projectFilePath = reader.ReadString();
for (var j = 0; j < referenceCount; j++)
{
var referenceFilePath = reader.ReadString();
var referenceProject = GetProject(solution, referenceFilePath);
if (referenceProject == null)
{
return(null);
}
references.Add(referenceProject.Id);
}
var project = GetProject(solution, projectFilePath);
if (project == null)
{
return(null);
}
map = map.Add(project.Id, ImmutableHashSet.CreateRange <ProjectId>(references));
reverseMap = reverseMap.AddAll(references, project.Id);
}
return(new ProjectDependencyGraph(solution, graphVersion, map, reverseMap));
}
public void Durable_CRDT_should_work_in_a_multi_node_cluster()
{
Join(second, first);
var r = NewReplicator(Sys);
Within(TimeSpan.FromSeconds(10), () =>
{
AwaitAssert(() =>
{
r.Tell(Dsl.GetReplicaCount);
ExpectMsg(new ReplicaCount(2));
});
});
EnterBarrier("both-initialized");
r.Tell(Dsl.Update(keyA, GCounter.Empty, writeTwo, c => c.Increment(cluster)));
ExpectMsg(new UpdateSuccess(keyA, null));
r.Tell(Dsl.Update(keyC, ORSet <string> .Empty, writeTwo, c => c.Add(cluster, Myself.Name)));
ExpectMsg(new UpdateSuccess(keyC, null));
EnterBarrier("update-done-" + testStepCounter);
r.Tell(Dsl.Get(keyA, readTwo));
ExpectMsg <GetSuccess>().Get(keyA).Value.ShouldBe(2UL);
r.Tell(Dsl.Get(keyC, readTwo));
ExpectMsg <GetSuccess>().Get(keyC).Elements.ShouldBe(ImmutableHashSet.CreateRange(new[] { first.Name, second.Name }));
EnterBarrier("values-verified-" + testStepCounter);
Watch(r);
Sys.Stop(r);
ExpectTerminated(r);
var r2 = default(IActorRef);
AwaitAssert(() => r2 = NewReplicator(Sys)); // try until name is free
AwaitAssert(() =>
{
r2.Tell(Dsl.GetKeyIds);
ExpectMsg <GetKeysIdsResult>().Keys.ShouldNotBe(ImmutableHashSet <string> .Empty);
});
r2.Tell(Dsl.Get(keyA, ReadLocal.Instance));
ExpectMsg <GetSuccess>().Get(keyA).Value.ShouldBe(2UL);
r2.Tell(Dsl.Get(keyC, ReadLocal.Instance));
ExpectMsg <GetSuccess>().Get(keyC).Elements.ShouldBe(ImmutableHashSet.CreateRange(new[] { first.Name, second.Name }));
EnterBarrierAfterTestStep();
}
protected IEnumerable <T> Filter <T>(string propName, IEnumerable <T> elements) where T : DrillingModelElement
{
var serialized = GetType().GetProperty(propName).GetValue(this);
if (serialized is string s)
{
var set = ImmutableHashSet.CreateRange(s.Split(new char[] { ';' }));
return(elements.Where(e => set.Contains(e.ID)));
}
return(Enumerable.Empty <T>());
}
protected override ImmutableHashSet <IMethodSymbol> OnCompilationStart(Compilation compilation)
{
var awaitHelper = compilation.GetTypeByMetadataNameNonNull("Cesil.AwaitHelper");
var methodsMustBeCalled =
ImmutableHashSet.CreateRange(
awaitHelper.GetMembers("ConfigureCancellableAwait").OfType <IMethodSymbol>()
);
return(methodsMustBeCalled);
}
public SymbolGroup(ImmutableArray <ISymbol> symbols)
{
Contract.ThrowIfTrue(symbols.IsDefaultOrEmpty);
// We should only get an actual group of symbols if these were from source.
// Metadata symbols never form a group.
Contract.ThrowIfTrue(symbols.Length >= 2 && symbols.Any(s => s.Locations.Any(loc => loc.IsInMetadata)));
Symbols = ImmutableHashSet.CreateRange(
MetadataUnifyingEquivalenceComparer.Instance, symbols);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="observer">TBD</param>
/// <returns>TBD</returns>
public ImmutableHashSet <UniqueAddress> AllUnreachableFrom(UniqueAddress observer)
{
var observerRows = ObserverRows(observer);
if (observerRows == null)
{
return(ImmutableHashSet.Create <UniqueAddress>());
}
return
(ImmutableHashSet.CreateRange(
observerRows.Where(p => p.Value.Status == ReachabilityStatus.Unreachable).Select(p => p.Key)));
}
public void ReadImmutableHashSetOfInt32()
{
ImmutableHashSet <int> expected = ImmutableHashSet.CreateRange(new[] { 1, 2, 3 });
const string json = "[1,2,3]";
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
ImmutableHashSet <int> actual = JsonSerializer.Deserialize <ImmutableHashSet <int> >(json, options);
Assert.Equal(expected, actual);
}
public LocalPackagesMemoryIndexes(IServiceProvider serviceProvider)
{
using (var scope = serviceProvider.CreateScope())
{
this._packageNames = ImmutableHashSet.CreateRange(scope.ServiceProvider
.GetRequiredService <LiteDBDatabaseService <T> >()
.GetPackageInfoDbSet()
.FindAll()
.Select(z => z.PackageName)
.ToArray());
}
}
public void ShouldExtendImmutableSetByMinusMethod()
{
// given
IImmutableSet <int> set = ImmutableHashSet.CreateRange(Lists.AsList(1, 2, 3));
// when
var result = set.Minus(Lists.AsList(1, 3, 4));
// then
Check.That(result).HasSize(1);
Check.That(result).Contains(2);
}
public void ShouldExtendImmutableSetByPlusMethod()
{
// given
IImmutableSet <string> set = ImmutableHashSet.CreateRange(Lists.AsList("A", "B"));
// when
var result = set.Plus(Lists.AsList("B", "C", "D"));
// then
Check.That(result).HasSize(4);
Check.That(result).Contains("A", "B", "C", "D");
}
