public bool Overlaps(CustomSet <T> other)
{
if (factory != other.factory)
{
throw new NotImplementedException();
}
return(set.Overlaps(other.set));
}
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]);
}
}
public bool Overlaps(IEnumerable <string> other)
{
return(_set.Overlaps(other));
}
private ImmutableArray <CompletionProvider> GetAllProviders(ImmutableHashSet <string> roles)
{
if (ExclusiveProviders.HasValue)
{
return(ExclusiveProviders.Value);
}
var builtin = GetBuiltInProviders();
var imported = GetImportedProviders()
.Where(lz => lz.Metadata.Roles == null || lz.Metadata.Roles.Length == 0 || roles.Overlaps(lz.Metadata.Roles))
.Select(lz => lz.Value);
var providers = builtin.Concat(imported).Concat(_testProviders);
return(providers.ToImmutableArray());
}
private ImmutableArray <CompletionProvider> GetAllProviders(ImmutableHashSet <string> roles)
{
var imported = GetImportedProviders()
.Where(lz => lz.Metadata.Roles == null || lz.Metadata.Roles.Length == 0 || roles.Overlaps(lz.Metadata.Roles))
.Select(lz => lz.Value);
#pragma warning disable 0618
// We need to keep supporting built-in providers for a while longer since this is a public API.
// https://github.com/dotnet/roslyn/issues/42367
var builtin = GetBuiltInProviders();
#pragma warning restore 0618
return(imported.Concat(builtin).ToImmutableArray());
}
protected ImmutableArray<CompletionProvider> GetProviders(ImmutableHashSet<string> roles)
{
roles = roles ?? ImmutableHashSet<string>.Empty;
RoleProviders providers;
if (!_roleProviders.TryGetValue(roles, out providers))
{
providers = _roleProviders.GetValue(roles, _ =>
{
var builtin = GetBuiltInProviders();
var imported = GetImportedProviders()
.Where(lz => lz.Metadata.Roles == null || lz.Metadata.Roles.Length == 0 || roles.Overlaps(lz.Metadata.Roles))
.Select(lz => lz.Value);
return new RoleProviders { Providers = builtin.Concat(imported).ToImmutableArray() };
});
}
if (_testProviders.Length > 0)
{
return providers.Providers.Concat(_testProviders);
}
else
{
return providers.Providers;
}
}
protected ImmutableArray <CompletionProvider> GetProviders(ImmutableHashSet <string> roles)
{
roles = roles ?? ImmutableHashSet <string> .Empty;
RoleProviders providers;
if (!_roleProviders.TryGetValue(roles, out providers))
{
providers = _roleProviders.GetValue(roles, _ =>
{
var builtin = GetBuiltInProviders();
var imported = GetImportedProviders()
.Where(lz => lz.Metadata.Roles == null || lz.Metadata.Roles.Length == 0 || roles.Overlaps(lz.Metadata.Roles))
.Select(lz => lz.Value);
return(new RoleProviders {
Providers = builtin.Concat(imported).ToImmutableArray()
});
});
}
if (_testProviders.Length > 0)
{
return(providers.Providers.Concat(_testProviders));
}
else
{
return(providers.Providers);
}
}
public bool CheckCollisions(Piece piece, ImmutableHashSet<Point> gameField, int width, int height)
{
return piece.Coordinates
.Any(cell => cell.AbsX < 0 || cell.AbsY < 0
|| cell.AbsX >= width || cell.AbsY >= height) || gameField.Overlaps(piece.Coordinates);
}
private ImmutableArray <CompletionProvider> GetAllProviders(ImmutableHashSet <string> roles)
{
var imported = GetImportedProviders()
.Where(lz => lz.Metadata.Roles == null || lz.Metadata.Roles.Length == 0 || roles.Overlaps(lz.Metadata.Roles))
.Select(lz => lz.Value);
return(imported.ToImmutableArray());
}
