public Enumerator(ValueSet v) { if (v._value == null) { _value = default(V); _values = default(ImmutableHashSet <V> .Enumerator); _count = 0; } else { ImmutableHashSet <V> set = v._value as ImmutableHashSet <V>; if (set == null) { _value = (V)v._value; _values = default(ImmutableHashSet <V> .Enumerator); _count = 1; } else { _value = default(V); _values = set.GetEnumerator(); _count = set.Count; Debug.Assert(_count > 1); } Debug.Assert(_count == v.Count); } }
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 void CopyTo(T[] array, int arrayIndex) { using var enumerator = set.GetEnumerator(); for (int i = arrayIndex; i < array.Length; i++) { array[i] = factory.indexToItem[enumerator.Current]; if (!enumerator.MoveNext()) { return; } } }
public IEnumerator <string> GetEnumerator() { return(_reasons.GetEnumerator()); }
protected override ImmutableHashSet <T> .Enumerator GetSourceEnumerator(ImmutableHashSet <T> source) { return(source.GetEnumerator()); }
/// <inheritdoc /> public IEnumerator <T> GetEnumerator() { return(_set.GetEnumerator()); }
public ImmutableHashSet <string> .Enumerator GetEnumerator() { return(_reasons.GetEnumerator()); }
/// <summary> /// Returns an enumerator that iterates through the collection. /// </summary> /// <returns> /// An enumerator that can be used to iterate through the collection. /// </returns> public IEnumerator <T> GetEnumerator() => _data.GetEnumerator();
public IEnumerator GetEnumerator() { return(_words.GetEnumerator()); }
public IEnumerator <ILspHandlerDescriptor> GetEnumerator() => _descriptors.GetEnumerator();
internal override void WritePacked(ref ProtoWriter.State state, ImmutableHashSet <T> values, IMeasuringSerializer <T> serializer, WireType wireType) { var iter = values.GetEnumerator(); WritePacked(ref state, ref iter, serializer, wireType); }
internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, ImmutableHashSet <T> values, ISerializer <T> serializer) { var iter = values.GetEnumerator(); Write(ref state, fieldNumber, category, wireType, ref iter, serializer); }
internal override long Measure(ImmutableHashSet <T> values, IMeasuringSerializer <T> serializer, ISerializationContext context, WireType wireType) { var iter = values.GetEnumerator(); return(Measure(ref iter, serializer, context, wireType)); }
public ImmutableHashSet <TSource> .Enumerator Invoke(ImmutableHashSet <TSource> source) => source.GetEnumerator();
public IEnumerator <Coin> GetEnumerator() { return(_coins.GetEnumerator()); }