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