public Map(int id, bool[,] filled, PositionedUnit unit, ImmutableStack<Unit> nextUnits, ImmutableHashSet<PositionedUnit> usedPositions, Scores scores, bool died = false) { Id = id; NextUnits = nextUnits; Width = filled.GetLength(0); Height = filled.GetLength(1); Filled = filled; Unit = IsValidPosition(unit) ? unit : PositionedUnit.Null; UsedPositions = usedPositions.Add(Unit); Scores = scores; Died = died; }
public override IDependency BeforeAdd( string projectPath, ITargetFramework targetFramework, IDependency dependency, ImmutableDictionary <string, IDependency> .Builder worldBuilder, ImmutableHashSet <IDependency> .Builder topLevelBuilder) { IDependency resultDependency = dependency; if (!dependency.TopLevel) { return(resultDependency); } if (dependency.Flags.Contains(DependencyTreeFlags.SdkSubTreeNodeFlags)) { // find package with the same name var packageModelId = dependency.Name; var packageId = Dependency.GetID(targetFramework, PackageRuleHandler.ProviderTypeString, packageModelId); if (worldBuilder.TryGetValue(packageId, out IDependency package) && package.Resolved) { resultDependency = dependency.SetProperties( dependencyIDs: package.DependencyIDs, resolved: true, flags: dependency.Flags.Union(DependencyTreeFlags.ResolvedFlags) .Except(DependencyTreeFlags.UnresolvedFlags)); } } else if (dependency.Flags.Contains(DependencyTreeFlags.PackageNodeFlags) && dependency.Resolved) { // find sdk with the same name var sdkModelId = dependency.Name; var sdkId = Dependency.GetID(targetFramework, SdkRuleHandler.ProviderTypeString, sdkModelId); if (worldBuilder.TryGetValue(sdkId, out IDependency sdk)) { sdk = sdk.SetProperties( dependencyIDs: dependency.DependencyIDs, resolved: true, flags: dependency.Flags.Union(DependencyTreeFlags.ResolvedFlags) .Except(DependencyTreeFlags.UnresolvedFlags)); worldBuilder.Remove(sdk.Id); worldBuilder.Add(sdk.Id, sdk); topLevelBuilder.Remove(sdk); topLevelBuilder.Add(sdk); } } return(resultDependency); }
private void UpdateDependenciesSnapshot( ImmutableDictionary <ITargetFramework, IDependenciesChanges> changes, IProjectCatalogSnapshot catalogs, ITargetFramework activeTargetFramework, CancellationToken token) { IImmutableSet <string> projectItemSpecs = GetProjectItemSpecsFromSnapshot(); TryUpdateSnapshot( snapshot => DependenciesSnapshot.FromChanges( _commonServices.Project.FullPath, snapshot, changes, catalogs, activeTargetFramework, _snapshotFilters.ToImmutableValueArray(), _subTreeProviders.ToValueDictionary(p => p.ProviderType, StringComparers.DependencyProviderTypes), projectItemSpecs), token); return; // Gets the set of items defined directly the project, and not included by imports. IImmutableSet <string> GetProjectItemSpecsFromSnapshot() { // We don't have catalog snapshot, we're likely updating because one of our project // dependencies changed. Just return 'no data' if (catalogs == null) { return(null); } ImmutableHashSet <string> .Builder itemSpecs = ImmutableHashSet.CreateBuilder(StringComparer.OrdinalIgnoreCase); foreach (ProjectItemInstance item in catalogs.Project.ProjectInstance.Items) { if (item.IsImported()) { continue; } // Returns unescaped evaluated include string itemSpec = item.EvaluatedInclude; if (itemSpec.Length != 0) { itemSpecs.Add(itemSpec); } } return(itemSpecs.ToImmutable()); } }
private void DownOrAddPending(UniqueAddress node) { if (_leader) { Down(node.Address); } else { // it's supposed to be downed by another node, current leader, but if that crash // a new leader must pick up these _pendingUnreachable = _pendingUnreachable.Add(node); } }
public void BeforeRemove( string projectPath, ITargetFramework targetFramework, IDependency dependency, ImmutableDictionary <string, IDependency> .Builder worldBuilder, ImmutableHashSet <IDependency> .Builder topLevelBuilder) { if (_beforeRemove.TryGetValue(dependency.Id, out IDependency newDependency)) { worldBuilder[newDependency.Id] = newDependency; topLevelBuilder.Add(newDependency); } }
private static ImmutableHashSet <IFieldSymbol> AddFieldIfNeeded(IFieldSymbol fieldSymbol, ExpressionSyntax expression, ImmutableHashSet <IFieldSymbol> fieldsAssigned) { var objectCreation = expression as ObjectCreationExpressionSyntax; if (objectCreation == null || !IsNonStaticNonPublicDisposableField(fieldSymbol)) { return(fieldsAssigned); } return(fieldsAssigned.Add(fieldSymbol)); }
private Task StartWorker(Func <int, Task> work) { int workerId = idleWorkers.Min(); idleWorkers = idleWorkers.Remove(workerId); Task doingWork = Task.Run ( async() => { try { await work(workerId); } finally { CompleteWork(workerId); } } ); busyWorkers = busyWorkers.Add(workerId); return(Task.FromResult(doingWork)); }
public void SetKind(string?kind) { kind = kind._NonNullTrim(); ImmutableHashSet <string> hash = ImmutableHashSet <string> .Empty; foreach (string token in kind.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries)) { hash = hash.Add(token); } this.KindHash = hash; }
public ImmutableHashSet <object> VisitZenArbitraryExpr <T>(ZenArbitraryExpr <T> expression, Unit parameter) { return(LookupOrCompute(expression, () => { var result = emptySet.Add(expression); if (!this.DisjointSets.ContainsKey(expression)) { this.DisjointSets[expression] = result; } return result; })); }
public void Register(IDiagnosticUpdateSource source) { lock (_gate) { if (_updateSources.Contains(source)) { return; } _updateSources = _updateSources.Add(source); source.DiagnosticsUpdated += OnDiagnosticsUpdated; } }
public PrintingConfig <TOwner> Excluding <TPropType>(Expression <Func <TOwner, TPropType> > memberSelector) { if (!(memberSelector.Body is MemberExpression memberExpression && memberExpression.Member is PropertyInfo propertyInfo)) { throw new ArgumentException("Selector expression is invalid"); } var name = propertyInfo.Name; var names = _forbiddenNames.Add(name); return(new PrintingConfig <TOwner>(names, _forbiddenTypes, _changedTypes)); }
public PrintingConfig <TOwner> Excluding <T>(Expression <Func <TOwner, T> > func) { var memberExpression = func.Body as MemberExpression; var propertyInfo = memberExpression?.Member as PropertyInfo; if (propertyInfo == null) { throw new ArgumentException("Function must be MemberExpression and return Property."); } var newExcludingProperty = excludingProperty.Add(propertyInfo); return(new PrintingConfig <TOwner>(excludingTypes, specificPrintForType, newExcludingProperty, specificPrintForProperty)); }
public override byte[] Rent(int minimumLength) { var array = source.Rent(minimumLength); if (rentArrays.Contains(array)) { throw new Exception("Same array returned"); } rentArrays = rentArrays.Add(array); Operations++; return(array); }
public void A_remote_round_robin_pool_with_resizer_must_be_locally_instantiated_on_a_remote_node_after_several_resize_rounds() { Within(TimeSpan.FromSeconds(5), () => { RunOn(() => { EnterBarrier("start", "broadcast-end", "end"); }, _config.First, _config.Second, _config.Third); RunOn(() => { EnterBarrier("start"); var actor = Sys.ActorOf(new RoundRobinPool( nrOfInstances: 1, resizer: new TestResizer() ).Props(Props.Create <SomeActor>()), "service-hello2"); actor.Should().BeOfType <RoutedActorRef>(); actor.Tell(RouterMessage.GetRoutees); // initial nrOfInstances 1 + initial resize => 2 ExpectMsg <Routees>().Members.Count().Should().Be(2); ImmutableHashSet <IActorRef> repliesFrom = ImmutableHashSet.Create <IActorRef>(); for (int i = 3; i <= 9; i++) { //each message triggers a resize, incrementing number of routees with 1 actor.Tell("hit"); var routees = actor.AskAndWait <Routees>(new GetRoutees(), GetTimeoutOrDefault(null)); routees.Members.Count().Should().Be(i); repliesFrom = repliesFrom.Add(ExpectMsg <IActorRef>()); } EnterBarrier("broadcast-end"); actor.Tell(new Broadcast(PoisonPill.Instance)); EnterBarrier("end"); repliesFrom.Count.Should().Be(7); var repliesFromAddresses = repliesFrom.Select(x => x.Path.Address).ToImmutableHashSet(); repliesFromAddresses.Should().BeEquivalentTo(new List <Address> { Node(_config.First).Address, Node(_config.Second).Address, Node(_config.Third).Address }); Sys.Stop(actor); }, _config.Fourth); EnterBarrier("done"); }); }
/** * Converts/validates a list of strings representing port ranges to an expanded list of {@link * Port}s. * * <p>For example: ["1000", "2000-2002"] will expand to a list of {@link Port}s with the port * numbers [1000, 2000, 2001, 2002] * * @param ports the list of port numbers/ranges, with an optional protocol separated by a '/' * (defaults to TCP if missing). * @return the ports as a list of {@link Port} * @throws NumberFormatException if any of the ports are in an invalid format or out of range */ public static ImmutableHashSet <Port> Parse(IEnumerable <string> ports) { ports = ports ?? throw new ArgumentNullException(nameof(ports)); ImmutableHashSet <Port> .Builder result = ImmutableHashSet.CreateBuilder <Port>(); foreach (string port in ports) { Match matcher = PortPattern.Match(port); if (!matcher.Success) { throw new FormatException( "Invalid port configuration: '" + port + "'. Make sure the port is a single number or a range of two numbers separated " + "with a '-', with or without protocol specified (e.g. '<portNum>/tcp' or " + "'<portNum>/udp')."); } // Parse protocol int min = int.Parse(matcher.Groups[1].Value, CultureInfo.InvariantCulture); int max = min; if (!string.IsNullOrEmpty(matcher.Groups[2].Value)) { max = int.Parse(matcher.Groups[2].Value, CultureInfo.InvariantCulture); } string protocol = matcher.Groups[3].Value; // Error if configured as 'max-min' instead of 'min-max' if (min > max) { throw new FormatException( "Invalid port range '" + port + "'; smaller number must come first."); } // Warn for possibly invalid port numbers if (min < 1 || max > 65535) { throw new FormatException( "Port number '" + port + "' is out of usual range (1-65535)."); } for (int portNumber = min; portNumber <= max; portNumber++) { result.Add(Port.ParseProtocol(portNumber, protocol)); } } return(result.ToImmutable()); }
public static void AppendToAliasNameSet(this string alias, ImmutableHashSet <string> .Builder builder) { if (string.IsNullOrWhiteSpace(alias)) { return; } builder.Add(alias); var caseSensitive = builder.KeyComparer == StringComparer.Ordinal; Contract.Requires(builder.KeyComparer == StringComparer.Ordinal || builder.KeyComparer == StringComparer.OrdinalIgnoreCase); string aliasWithoutAttribute; if (alias.TryGetWithoutAttributeSuffix(caseSensitive, out aliasWithoutAttribute)) { builder.Add(aliasWithoutAttribute); return; } builder.Add(alias.GetWithSingleAttributeSuffix(caseSensitive)); }
static void Main(string[] args) { ImmutableHashSet <int> il = ImmutableHashSet.Create <int>(); il = il.Add(1); il = il.Add(2); il = il.Remove(2); ImmutableHashSet <int> .Builder issBuilder = il.ToBuilder(); issBuilder.Add(10); //adds to original Hashset. returns void. ImmutableHashSet <int> .Builder builder = ImmutableHashSet.CreateBuilder <int>(); builder.Add(1); il = builder.ToImmutable(); }
private static async Task <(DiagnosticAnalysisResult loadDiagnostics, ImmutableHashSet <Document>?failedDocuments)> GetDocumentLoadFailuresAsync( Project project, VersionStamp version, CancellationToken cancellationToken ) { ImmutableHashSet <Document> .Builder?failedDocuments = null; ImmutableDictionary < DocumentId, ImmutableArray <DiagnosticData> > .Builder?lazyLoadDiagnostics = null; foreach (var document in project.Documents) { var loadDiagnostic = await document.State .GetLoadDiagnosticAsync(cancellationToken) .ConfigureAwait(false); if (loadDiagnostic != null) { lazyLoadDiagnostics ??= ImmutableDictionary.CreateBuilder < DocumentId, ImmutableArray <DiagnosticData> >(); lazyLoadDiagnostics.Add( document.Id, ImmutableArray.Create(DiagnosticData.Create(loadDiagnostic, document)) ); failedDocuments ??= ImmutableHashSet.CreateBuilder <Document>(); failedDocuments.Add(document); } } var result = DiagnosticAnalysisResult.Create( project, version, syntaxLocalMap: lazyLoadDiagnostics?.ToImmutable() ?? ImmutableDictionary <DocumentId, ImmutableArray <DiagnosticData> > .Empty, semanticLocalMap: ImmutableDictionary < DocumentId, ImmutableArray <DiagnosticData> > .Empty, nonLocalMap: ImmutableDictionary <DocumentId, ImmutableArray <DiagnosticData> > .Empty, others: ImmutableArray <DiagnosticData> .Empty, documentIds: null ); return(result, failedDocuments?.ToImmutable()); }
protected override void GetComponentTypes(ImmutableHashSet <Type> .Builder types) { types.Add(typeof(Transform)); types.Add(typeof(Collider)); types.Add(typeof(RenderProperties)); types.Add(typeof(BSPRenderableComponent)); types.Add(typeof(LinearMovementLocomotor)); types.Add(typeof(LinearDoor)); }
/// <inheritdoc /> public void Attach(ITelemetryEventTransmitter transmitter) { if (transmitter == null) { throw new ArgumentNullException(nameof(transmitter)); } lock (_lock) { if (!_transmitters.Contains(transmitter)) { _transmitters = _transmitters.Add(transmitter); } } }
public override SyntaxNode?VisitUsingDirective(UsingDirectiveSyntax node) { if (unusedUsingSpan.Any(s => s.Contains(node.Span))) { return(null); } if (node.Parent.IsKind(SyntaxKind.CompilationUnit)) { rootUsingsBuilder.Add(node.NormalizeWhitespace().ToString().Trim()); return(null); } return(base.VisitUsingDirective(node)); }
public void ToImmutableHashSet() { ImmutableHashSet <int> .Builder builder = ImmutableHashSet.CreateBuilder <int>(); builder.Add(1); builder.Add(2); builder.Add(3); var set = builder.ToImmutableSortedSet(); Assert.True(builder.Contains(1)); Assert.True(builder.Contains(2)); Assert.True(builder.Contains(3)); builder.Remove(3); Assert.False(builder.Contains(3)); Assert.True(set.Contains(3)); builder.Clear(); Assert.True(builder.ToImmutableHashSet().IsEmpty); Assert.False(set.IsEmpty); ImmutableHashSet <int> .Builder nullBuilder = null; AssertExtensions.Throws <ArgumentNullException>("builder", () => nullBuilder.ToImmutableHashSet()); }
/// <summary> /// Merge another field node into this selection. /// </summary> /// <param name="other"> /// The other field node. /// </param> /// <returns> /// Returns a new field selection that combines /// the other field node into this selection. /// </returns> public FieldSelection Merge(FieldNode other) { if (other == null) { throw new ArgumentNullException(nameof(other)); } return(new FieldSelection ( MergeField(Selection, other), Field, ResponseName, _nodes.Add(other) )); }
public void MergeDependencies( ref TAssemblySymbol?primaryDependency, ref ImmutableHashSet <TAssemblySymbol>?secondaryDependencies ) { secondaryDependencies = ( secondaryDependencies ?? ImmutableHashSet <TAssemblySymbol> .Empty ).Union(SecondaryDependencies ?? ImmutableHashSet <TAssemblySymbol> .Empty); primaryDependency ??= PrimaryDependency; if (!object.Equals(primaryDependency, PrimaryDependency) && PrimaryDependency is object) { secondaryDependencies = secondaryDependencies.Add(PrimaryDependency); } }
private static void CollectReturnedLocals(ReturnStatementSyntax returnStatement, SemanticModel semanticModel, ref ImmutableHashSet <ILocalSymbol> localsReturned) { if (returnStatement.Expression == null) { return; } var localSymbol = semanticModel.GetSymbolInfo(returnStatement.Expression).Symbol as ILocalSymbol; if (IsDisposableLocalSymbol(localSymbol)) { localsReturned = localsReturned.Add(localSymbol); } }
// Internal, for test use -- normal code should use the factory methods internal TargetedDependenciesSnapshot( string projectPath, ITargetFramework targetFramework, IProjectCatalogSnapshot catalogs, ImmutableDictionary <string, IDependency> dependenciesWorld) { Requires.NotNullOrEmpty(projectPath, nameof(projectPath)); Requires.NotNull(targetFramework, nameof(targetFramework)); // catalogs can be null Requires.NotNull(dependenciesWorld, nameof(dependenciesWorld)); ProjectPath = projectPath; TargetFramework = targetFramework; Catalogs = catalogs; DependenciesWorld = dependenciesWorld; bool hasUnresolvedDependency = false; ImmutableHashSet <IDependency> .Builder topLevelDependencies = ImmutableHashSet.CreateBuilder <IDependency>(); foreach ((string id, IDependency dependency) in dependenciesWorld) { System.Diagnostics.Debug.Assert( string.Equals(id, dependency.Id), "dependenciesWorld dictionary entry keys must match their value's ids."); if (!dependency.Resolved) { hasUnresolvedDependency = true; } if (dependency.TopLevel) { bool added = topLevelDependencies.Add(dependency); System.Diagnostics.Debug.Assert(added, "Duplicate top level dependency found."); if (!string.IsNullOrEmpty(dependency.Path)) { _topLevelDependenciesByPathMap.Add( Dependency.GetID(TargetFramework, dependency.ProviderType, dependency.Path), dependency); } } } HasUnresolvedDependency = hasUnresolvedDependency; TopLevelDependencies = topLevelDependencies.ToImmutable(); }
/// <summary> /// Find Type or skip /// </summary> /// <returns>if <see langword="false"/>, ignore <paramref name="node"/></returns> private bool FindDeclaredType(MemberDeclarationSyntax node) { if (model.GetDeclaredSymbol(node, cancellationToken) is not ITypeSymbol symbol) { return(false); } var typeName = symbol?.ToDisplayString(); if (typeName is not null) { definedTypesBuilder.Add(typeName); return(true); } return(false); }
public static ImmutableHashSet <T> AddUntilSuccessfulOrNull <T>(ref ImmutableHashSet <T> destination, T valueToAdd) { ImmutableHashSet <T> formerCollection = Volatile.Read(ref destination); bool exchangeSucceeded = false; while (formerCollection != null && exchangeSucceeded == false) { ImmutableHashSet <T> newCollection = formerCollection.Add(valueToAdd); ImmutableHashSet <T> exchangeResult = Interlocked.CompareExchange(ref destination, newCollection, formerCollection); exchangeSucceeded = ReferenceEquals(exchangeResult, formerCollection); formerCollection = exchangeResult; } return(formerCollection); }
private static void CategorizeLines(string line, int lineNumber, ImmutableHashSet <int> .Builder noSonar, ImmutableHashSet <int> .Builder nonBlank) { if (line.Contains("NOSONAR")) { nonBlank.Remove(lineNumber); noSonar.Add(lineNumber); } else { if (HasValidCommentContent(line) && !noSonar.Contains(lineNumber)) { nonBlank.Add(lineNumber); } } }
public bool TryMarkKeyPrefixAsMissingOrEmpty(string keyPrefix, out ConsulState updatedState) { if (_missingKeyPrefixes.Contains(keyPrefix)) { updatedState = null; return(false); } var kvStore = _kvStore; if (_kvStore.TryRemoveKeysStartingWith(keyPrefix, out var updatedKvStore)) { kvStore = updatedKvStore; } updatedState = new ConsulState(_services, kvStore, _missingKeyPrefixes.Add(keyPrefix)); return(true); }
/// <summary> /// Initializes a new alternation set. /// </summary> /// <param name="setElements">The elements of this set.</param> public NegatedSet(params SetElement[] setElements) { if (setElements is null) { throw new ArgumentNullException(nameof(setElements)); } if (setElements.Length < 1) { throw new ArgumentException("At least 1 set element is required.", nameof(setElements)); } ImmutableHashSet <Char> .Builder characters = ImmutableHashSet.CreateBuilder <Char>(); ImmutableHashSet <Range <Char> > .Builder ranges = ImmutableHashSet.CreateBuilder <Range <Char> >(); ImmutableHashSet <UnicodeCategory> .Builder categories = ImmutableHashSet.CreateBuilder <UnicodeCategory>(); ImmutableHashSet <GrammarNode <Char> > .Builder nodes = ImmutableHashSet.CreateBuilder <GrammarNode <Char> >(); for (var elementIdx = 0; elementIdx < setElements.Length; elementIdx++) { SetElement setElement = setElements[elementIdx]; switch (setElement.Type) { case SetElementType.Character: characters.Add(setElement.Character); break; case SetElementType.Range: ranges.Add(setElement.Range); break; case SetElementType.UnicodeCategory: categories.Add(setElement.UnicodeCategory); break; case SetElementType.Node: nodes.Add(setElement.Node); break; case SetElementType.Invalid: default: throw new InvalidOperationException($"Invalid set element provided at index {elementIdx}."); } } this.Characters = characters.ToImmutable(); this.Ranges = ranges.ToImmutable(); this.UnicodeCategories = categories.ToImmutable(); this.Nodes = nodes.ToImmutable(); }
private static void ProcessExpressionChange(ExpressionSyntax expression, SemanticModel semanticModel, ref ImmutableHashSet<IFieldSymbol> nonCandidateFields, ref ImmutableHashSet<IFieldSymbol> assignedAsReadonly) { var fieldSymbol = semanticModel.GetSymbolInfo(expression).Symbol as IFieldSymbol; if (fieldSymbol== null || !FieldIsRelevant(fieldSymbol)) { return; } var constructorSymbol = semanticModel.GetEnclosingSymbol(expression.SpanStart) as IMethodSymbol; if (constructorSymbol == null) { nonCandidateFields = nonCandidateFields.Add(fieldSymbol); return; } if (constructorSymbol.MethodKind == MethodKind.Constructor && constructorSymbol.ContainingType.Equals(fieldSymbol.ContainingType)) { assignedAsReadonly = assignedAsReadonly.Add(fieldSymbol); } else { nonCandidateFields = nonCandidateFields.Add(fieldSymbol); } }
private static ImmutableHashSet<IFieldSymbol> AddFieldIfNeeded(IFieldSymbol fieldSymbol, ExpressionSyntax expression, ImmutableHashSet<IFieldSymbol> fieldsAssigned) { var objectCreation = expression as ObjectCreationExpressionSyntax; if (objectCreation == null || !IsNonStaticNonPublicDisposableField(fieldSymbol)) { return fieldsAssigned; } return fieldsAssigned.Add(fieldSymbol); }
public static void AppendToAliasNameSet(this string alias, ImmutableHashSet<string>.Builder builder) { if (string.IsNullOrWhiteSpace(alias)) { return; } builder.Add(alias); var caseSensitive = builder.KeyComparer == StringComparer.Ordinal; Contract.Requires(builder.KeyComparer == StringComparer.Ordinal || builder.KeyComparer == StringComparer.OrdinalIgnoreCase); string aliasWithoutAttribute; if (alias.TryGetWithoutAttributeSuffix(caseSensitive, out aliasWithoutAttribute)) { builder.Add(aliasWithoutAttribute); return; } builder.Add(alias.GetWithSingleAttributeSuffix(caseSensitive)); }
private static void CollectDisposeMethods(SymbolAnalysisContext c, IMethodSymbol disposeMethod, ref ImmutableHashSet<IMethodSymbol> allDisposeMethods, ref ImmutableHashSet<IMethodSymbol> implementingDisposeMethods) { var methodSymbol = c.Symbol as IMethodSymbol; if (methodSymbol == null || methodSymbol.Name != DisposeMethodName) { return; } allDisposeMethods = allDisposeMethods.Add(methodSymbol); if (methodSymbol.IsOverride || MethodIsDisposeImplementation(methodSymbol, disposeMethod) || MethodMightImplementDispose(methodSymbol)) { implementingDisposeMethods = implementingDisposeMethods.Add(methodSymbol); } }
public ClusterHeartbeatSenderState Init(ImmutableHashSet<UniqueAddress> nodes) { return Copy(ring: Ring.Copy(nodes: nodes.Add(SelfAddress))); }
/// <summary> /// /// </summary> /// <param name="shape"></param> /// <param name="rect"></param> /// <param name="selection"></param> /// <param name="builder"></param> /// <param name="treshold"></param> /// <param name="dx"></param> /// <param name="dy"></param> /// <returns></returns> private static bool HitTest( BaseShape shape, Rect2 rect, Vector2[] selection, ImmutableHashSet<BaseShape>.Builder builder, double treshold, double dx, double dy) { if (shape is XPoint) { if (GetPointBounds(shape as XPoint, treshold, dx, dy).IntersectsWith(rect)) { if (builder != null) { builder.Add(shape); } else { return true; } } return false; } else if (shape is XLine) { var line = shape as XLine; if (GetPointBounds(line.Start, treshold, dx, dy).IntersectsWith(rect) || GetPointBounds(line.End, treshold, dx, dy).IntersectsWith(rect) || MathHelpers.LineIntersectsWithRect(rect, new Point2(line.Start.X, line.Start.Y), new Point2(line.End.X, line.End.Y))) { if (builder != null) { builder.Add(line); return false; } else { return true; } } return false; } else if (shape is XEllipse) { if (GetEllipseBounds(shape as XEllipse, dx, dy).IntersectsWith(rect)) { if (builder != null) { builder.Add(shape); return false; } else { return true; } } return false; } else if (shape is XRectangle) { if (GetRectangleBounds(shape as XRectangle, dx, dy).IntersectsWith(rect)) { if (builder != null) { builder.Add(shape); return false; } else { return true; } } return false; } else if (shape is XArc) { if (GetArcBounds(shape as XArc, dx, dy).IntersectsWith(rect)) { if (builder != null) { builder.Add(shape); return false; } else { return true; } } return false; } else if (shape is XBezier) { if (ConvexHullBounds.Overlap(selection, ConvexHullBounds.GetVertices(shape as XBezier, dx, dy))) { if (builder != null) { builder.Add(shape); return false; } else { return true; } } return false; } else if (shape is XQBezier) { if (ConvexHullBounds.Overlap(selection, ConvexHullBounds.GetVertices(shape as XQBezier, dx, dy))) { if (builder != null) { builder.Add(shape); return false; } else { return true; } } return false; } else if (shape is XText) { if (GetTextBounds(shape as XText, dx, dy).IntersectsWith(rect)) { if (builder != null) { builder.Add(shape); return false; } else { return true; } } return false; } else if (shape is XImage) { if (GetImageBounds(shape as XImage, dx, dy).IntersectsWith(rect)) { if (builder != null) { builder.Add(shape); return false; } else { return true; } } return false; } else if (shape is XPath) { if ((shape as XPath).Geometry != null) { var points = (shape as XPath).GetAllPoints(); if (ConvexHullBounds.Overlap(selection, ConvexHullBounds.GetVertices(points, dx, dy))) { if (builder != null) { builder.Add(shape); return false; } else { return true; } } } return false; } else if (shape is XGroup) { if (HitTest((shape as XGroup).Shapes.Reverse(), rect, selection, null, treshold, dx, dy) == true) { if (builder != null) { builder.Add(shape); return false; } else { return true; } } return false; } return false; }