public bool MoveNext()
{
if (_position >= _uniqueKeys.Length)
{
return(false);
}
var currentKey = _uniqueKeys.Get(_position);
var groupLocalList = new LocalList <T>();
for (var i = 0; i < _values.Length; i++)
{
var value = _values.Get(i);
if (_comparer.Equals(currentKey, value.Key))
{
groupLocalList.Add(value.Value);
}
}
_current = new LocalGroup(currentKey, groupLocalList);
_position++;
return(true);
}
public void Contains_WithComparer <T>(T item)
{
var localList = new LocalList <T>();
localList.Add(item);
Assert.True(localList.Contains(item, EqualityComparer <T> .Default));
}
public void Contains <T>(T item)
{
var localList = new LocalList <T>();
localList.Add(item);
Assert.True(localList.Contains(item));
}
public void Any_AvoidClosure(int[] items)
{
var localList = new LocalList <int>();
foreach (var item in items)
{
localList.Add(item);
Assert.True(localList.Any((e, i) => e == i, item));
}
}
public void First_AvoidClosure(int[] items)
{
var localList = new LocalList <int>();
foreach (var item in items)
{
localList.Add(item);
Assert.Equal(item, localList.First((e, i) => e == i, item));
}
}
public TResult[] ToArray()
{
var localList = new LocalList <TResult>();
while (MoveNext())
{
localList.Add(_current);
}
return(localList.ToArray());
}
public void Any(int[] items)
{
var localList = new LocalList <int>();
foreach (var item in items)
{
localList.Add(item);
// ReSharper disable once HeapView.CanAvoidClosure
Assert.True(localList.Any(e => e == item));
}
}
public LocalList <TValue> Select <TValue>(Func <TResult, TValue> selector)
{
var localList = new LocalList <TValue>();
while (MoveNext())
{
localList.Add(selector(_current));
}
return(localList);
}
public void First(int[] items)
{
var localList = new LocalList <int>();
foreach (var item in items)
{
localList.Add(item);
// ReSharper disable once HeapView.CanAvoidClosure
Assert.Equal(item, localList.First(e => e == item));
}
}
public LocalList <TResult> Select <TResult>(Selector <TResult> selector)
{
var result = new LocalList <TResult>(_uniqueKeys._length);
while (MoveNext())
{
var element = selector(_current);
result.Add(element);
}
return(result);
}
public LocalList <TValue> OrderBy <TProperty>(Func <TValue, TProperty> path,
Comparer <TProperty> comparer = null)
{
var localList = new LocalList <TValue>();
while (_enumerator.MoveNext())
{
localList.Add(_selector(_enumerator.Current));
}
localList.Sort(path, comparer);
return(localList);
}
public LocalList <TResult> OrderBy <TProperty>(Func <TResult, TProperty> path,
Comparer <TProperty> comparer = null)
{
var localList = new LocalList <TResult>();
while (MoveNext())
{
localList.Add(_current);
}
localList.Sort(path, comparer);
return(localList);
}
public void Length(int[] items)
{
var localList = new LocalList <int>();
Assert.Equal(0, localList.Length);
for (var i = 0; i < items.Length; i++)
{
localList.Add(items[i]);
Assert.Equal(i + 1, localList.Length);
}
Assert.Equal(items.Length, localList.Length);
}
public LocalList <TResult> Where <TArg>(Func <TResult, TArg, bool> predicate, TArg arg)
{
var localList = new LocalList <TResult>();
while (MoveNext())
{
if (predicate(_current, arg))
{
localList.Add(_current);
}
}
return(localList);
}
public LocalList <TResult> Where(Predicate <TResult> predicate)
{
var localList = new LocalList <TResult>();
while (MoveNext())
{
if (predicate(_current))
{
localList.Add(_current);
}
}
return(localList);
}
public void GetEnumerator(int[] items)
{
var localList = new LocalList <int>();
foreach (var item in items)
{
localList.Add(item);
}
foreach (var element in localList)
{
Assert.Contains(element, items);
}
}
public void Clear(int[] items)
{
var localList = new LocalList <int>();
foreach (var item in items)
{
localList.Add(item);
}
localList.Clear();
Assert.True(localList.Length == 0);
Assert.Equal(0, localList.Length);
}
public LocalList <TValue> Where(Predicate <TValue> predicate)
{
var localList = new LocalList <TValue>();
while (_enumerator.MoveNext())
{
var current = _selector(_enumerator.Current);
if (predicate(current))
{
localList.Add(current);
}
}
return(localList);
}
public LocalList <TValue> Where <TArg>(Func <TValue, TArg, bool> predicate, TArg arg)
{
var localList = new LocalList <TValue>();
while (_enumerator.MoveNext())
{
var current = _selector(_enumerator.Current);
if (predicate(current, arg))
{
localList.Add(current);
}
}
return(localList);
}
public LocalList <TValue> Select <TValue>(Func <T, TValue> selector)
{
var localList = new LocalList <TValue>();
while (_enumerator.MoveNext())
{
var current = _enumerator.Current;
if (_predicate(current))
{
localList.Add(selector(current));
}
}
return(localList);
}
public T[] ToArray()
{
var localList = new LocalList <T>(_enumerator.Length);
while (_enumerator.MoveNext())
{
var current = _enumerator.Current;
if (_predicate(current))
{
localList.Add(current);
}
}
return(localList.ToArray());
}
public void Add_Many(int count)
{
count = FixCount(count);
var localList = new LocalList <int>();
var items = Enumerable.Range(0, count).ToArray();
foreach (var item in items)
{
localList.Add(item);
Assert.True(localList.Contains(item));
}
Assert.Equal(items.Length, localList.Length);
}
public LocalList <T> OrderBy <TProperty>(Func <T, TProperty> path, Comparer <TProperty> comparer = null)
{
var localList = new LocalList <T>();
while (_enumerator.MoveNext())
{
var current = _enumerator.Current;
if (_predicate(current))
{
localList.Add(current);
}
}
localList.Sort(path, comparer);
return(localList);
}
public LocalList <TValue> .JoinEnumerator <TResult, TInner, TKey> Join <TResult, TInner, TKey>(
LocalList <TInner> inner,
Func <TValue, TKey> outerKeySelector,
Func <TInner, TKey> innerKeySelector,
Func <TValue, TInner, TResult> resultBuilder,
EqualityComparer <TKey> keyComparer = null)
{
var outer = new LocalList <TValue>();
while (_enumerator.MoveNext())
{
outer.Add(_selector(_enumerator.Current));
}
return(outer.Join(inner, outerKeySelector, innerKeySelector, resultBuilder, keyComparer));
}
public LocalList <TResult> .GroupEnumerator <TGroupKey> GroupBy <TGroupKey>(
Func <TResult, TGroupKey> keySelector,
EqualityComparer <TGroupKey> keyComparer = null)
{
var localList = new LocalList <TResult>();
while (MoveNext())
{
localList.Add(_current);
}
if (keyComparer == null)
{
keyComparer = EqualityComparer <TGroupKey> .Default;
}
return(new LocalList <TResult> .GroupEnumerator <TGroupKey>(localList, keySelector, keyComparer));
}
public void Mix()
{
var items = new LocalList <int>();
for (var i = 0; i < 100; i++)
{
items.Add(i);
Assert.True(items.Contains(i));
if (i % 2 != 0)
{
continue;
}
Assert.True(items.Remove(i));
Assert.False(items.Contains(i));
}
}
public JoinEnumerator <TResult, TInner, TKey> Join <TResult, TInner, TKey>(
LocalList <TInner> inner,
Func <T, TKey> outerKeySelector,
Func <TInner, TKey> innerKeySelector,
Func <T, TInner, TResult> resultBuilder,
EqualityComparer <TKey> keyComparer = null)
{
var outer = new LocalList <T>();
while (_enumerator.MoveNext())
{
var current = _enumerator.Current;
if (_predicate(current))
{
outer.Add(current);
}
}
return(outer.Join(inner, outerKeySelector, innerKeySelector, resultBuilder, keyComparer));
}
public void Mix_Many(int count)
{
count = FixCount(count);
var localList = new LocalList <int>();
for (var i = 0; i < count; i++)
{
localList.Add(i);
Assert.True(localList.Contains(i));
if (i % 2 != 0)
{
continue;
}
Assert.True(localList.Remove(i));
Assert.False(localList.Contains(i));
}
}
internal GroupEnumerator(LocalList <T> list, Func <T, TKey> keySelector, EqualityComparer <TKey> comparer)
{
var values = new LocalList <Row <TKey, T> >(list.Length);
var uniqueKeys = new LocalList <TKey>();
for (var i = 0; i < list.Length; i++)
{
var element = list.Get(i);
var key = keySelector(element);
values.Add(new Row <TKey, T>(key, element));
if (!uniqueKeys.Contains(key, comparer))
{
uniqueKeys.Add(key);
}
}
_comparer = comparer;
_current = default;
_position = 0;
_values = values;
_uniqueKeys = uniqueKeys;
}
