/** * 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"); }