private ImmutableHashSet <RemoteObserver> GetEligibleObservers(ImmutableHashSet <RemoteObserver> allObservers, PublishOptions options) { ImmutableHashSet <RemoteObserver> result = allObservers; if (options.Eligible != null) { var eligibleObservers = GetRemoteObservers(options.Eligible) .ToArray(); result = ImmutableHashSet.Create(eligibleObservers); } if (options.EligibleAuthenticationIds != null) { ImmutableHashSet <RemoteObserver> gatheredAuthIdObservers = GatherObservers(mAuthenticationIdToSubscription, options.EligibleAuthenticationIds); result = result.Intersect(gatheredAuthIdObservers); } if (options.EligibleAuthenticationRoles != null) { ImmutableHashSet <RemoteObserver> gatheredAuthIdObservers = GatherObservers(mAuthenticationRoleToSubscription, options.EligibleAuthenticationRoles); result = result.Intersect(gatheredAuthIdObservers); } return(result); }
// Cognitive Complexity 5 public static ContentView GetContentView(string contentId, IReadOnlyCollection <string> requestedUriTypes) { ImmutableHashSet <string> subsetUriTypes = AllSupportedUriTypes.Intersect(requestedUriTypes); if (!subsetUriTypes.Any()) { throw new Exception("message"); } return(new ContentView { ResultStatus = AllSupportedUriTypes.SetEquals(subsetUriTypes) ? ResultStatusComplete : ResultStatusPartial, Uris = subsetUriTypes.Select(uriType => { if (IsViewerA(uriType)) { return $"https://{ViewerA}/{contentId}"; } else if (IsViewerC(uriType)) { return $"https://{ViewerC}/{contentId}"; } else { return $"https://{ViewerD}/{contentId}"; } }) }); }
public void ImmutableSetAdapter_Ctor_Succeeds() { const int NumberOfMethods = 17; int[] methodsCalled = new int[NumberOfMethods]; ImmutableHashSet <int> realSet = ImmutableHashSet <int> .Empty; System.Collections.Immutable.IImmutableSet <int> backingSet = new MockSystemImmutableSet <int>( addDelegate: x => { methodsCalled[0]++; return(realSet.Add(x)); }, clearDelegate: () => { methodsCalled[1]++; return(realSet.Clear()); }, containsDelegate: x => { methodsCalled[2]++; return(realSet.Contains(x)); }, countDelegate: () => { methodsCalled[3]++; return(realSet.Count); }, equalsDelegate: null, exceptDelegate: x => { methodsCalled[4]++; return(realSet.Except(x)); }, getEnumeratorDelegate: () => { methodsCalled[5]++; return(realSet.GetEnumerator()); }, getHashCodeDelegate: null, intersectDelegate: x => { methodsCalled[6]++; return(realSet.Intersect(x)); }, isProperSubsetOfDelegate: x => { methodsCalled[7]++; return(realSet.IsProperSubsetOf(x)); }, isProperSupersetOfDelegate: x => { methodsCalled[8]++; return(realSet.IsProperSupersetOf(x)); }, isSubsetOfDelegate: x => { methodsCalled[9]++; return(realSet.IsSubsetOf(x)); }, isSupersetOfDelegate: x => { methodsCalled[10]++; return(realSet.IsSupersetOf(x)); }, overlapsDelegate: x => { methodsCalled[11]++; return(realSet.Overlaps(x)); }, removeDelegate: x => { methodsCalled[12]++; return(realSet.Remove(x)); }, setEqualsDelegate: x => { methodsCalled[13]++; return(realSet.SetEquals(x)); }, symmetricExceptDelegate: x => { methodsCalled[14]++; return(realSet.SymmetricExcept(x)); }, toStringDelegate: null, tryGetValueDelegate: (int x, out int y) => { methodsCalled[15]++; return(realSet.TryGetValue(x, out y)); }, unionDelegate: x => { methodsCalled[16]++; return(realSet.Union(x)); }); #pragma warning disable IDE0028 // Simplify collection initialization. Intentionally calling .Add separately for clarity ImmutableSetAdapter <int> set = new ImmutableSetAdapter <int>(backingSet); #pragma warning restore IDE0028 // Simplify collection initialization. set.Add(12); set.Clear(); set.Contains(12); _ = set.Count; set.Except(Array.Empty <int>()); set.GetEnumerator(); set.Intersect(Array.Empty <int>()); set.IsProperSubsetOf(Array.Empty <int>()); set.IsProperSupersetOf(Array.Empty <int>()); set.IsSubsetOf(Array.Empty <int>()); set.IsSupersetOf(Array.Empty <int>()); set.Overlaps(Array.Empty <int>()); set.Remove(12); set.SetEquals(Array.Empty <int>()); set.SymmetricExcept(Array.Empty <int>()); set.TryGetValue(12, out _); set.Union(Array.Empty <int>()); for (int counter = 0; counter < NumberOfMethods; counter++) { Assert.AreEqual(1, methodsCalled[counter]); } }
private CircularDependencyException DependencyAlreadyExistsException(T key, ImmutableHashSet <T> current, IReadOnlyCollection <T> newDependencies) { var alreadyExisting = current.Intersect(newDependencies); Contract.Assert(alreadyExisting.Count != 0); if (alreadyExisting.Count == 1) { return(new CircularDependencyException($"The following dependency already exists: '{key}'->'{alreadyExisting.First()}'")); } else { string message = alreadyExisting.Select(alreadyExisting => $" '{key}'->'{alreadyExisting}'") .Join("\n"); return(new CircularDependencyException($"The following dependencies already exist: \n" + message)); } }
private static ImmutableHashSet <T> MergeOrIntersect(ImmutableHashSet <T> value1, ImmutableHashSet <T> value2, bool merge) { Debug.Assert(value1 != null); Debug.Assert(value2 != null); if (value1.IsEmpty) { return(value2); } else if (value2.IsEmpty || ReferenceEquals(value1, value2)) { return(value1); } var values = merge ? value1.Concat(value2) : value1.Intersect(value2); return(ImmutableHashSet.CreateRange(values)); }
private static IEnumerable <ImmutableHashSet <T> > FindCliques( IGraph <T> graph, ImmutableHashSet <T> potential_clique, ImmutableHashSet <T> remaining_nodes, ImmutableHashSet <T> skip_nodes) { if (potential_clique.IsEmpty && skip_nodes.IsEmpty) { yield return(remaining_nodes); } else { var choices = potential_clique.Union(skip_nodes); ImmutableHashSet <T> pivoted; if (choices.Count > 0) { var pivotVertex = choices.Shuffle().First(); pivoted = potential_clique.Except(graph.Neigbours(pivotVertex)); } else { pivoted = potential_clique; } foreach (var v in pivoted) { var neighborsOfV = graph.Neigbours(v); var sub = FindCliques( graph, potential_clique.Intersect(neighborsOfV), remaining_nodes.Add(v), skip_nodes.Intersect(neighborsOfV)); foreach (var s in sub) { yield return(s); } potential_clique = potential_clique.Remove(v); skip_nodes = skip_nodes.Add(v); } } }
/// <inheritdoc /> public IImmutableSet <T> Intersect(IEnumerable <T> other) { return(new SetEqualedReadOnlySet <T>(_set.Intersect(other))); }
public static bool IsPangram(string input) => alphabet.Intersect(input.ToLower()).Count == alphabet.Count;
static bool IsPangramSimple(string s) { return(alphabet.Intersect(s.ToLower()).Count == alphabet.Count); }