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;
}
