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