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