public static LinqRoot <IGrouping <K, T> > GroupBy <T, K>(IEnumerable <T> e, SigilFunc <T, K> p)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
var ret = new LinqList <IGrouping <K, T> >();
var gLookup = new Dictionary <K, Grouping <K, T> >();
using (var i = e.GetEnumerator())
{
while (i.MoveNext())
{
var k = p(i.Current);
Grouping <K, T> g;
if (!gLookup.TryGetValue(k, out g))
{
gLookup[k] = g = new Grouping <K, T>(k);
ret.Add(g);
}
g.Add(i.Current);
}
}
return(ret);
}
public static T SingleOrDefault <T>(IEnumerable <T> e, SigilFunc <T, bool> p)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
using (var i = e.GetEnumerator())
{
while (i.MoveNext())
{
if (p(i.Current))
{
var ret = i.Current;
while (i.MoveNext())
{
if (p(i.Current))
{
throw new InvalidOperationException();
}
}
return(ret);
}
}
return(default(T));
}
}
public static int Count <T>(IEnumerable <T> e, SigilFunc <T, bool> p)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
int ret = 0;
using (var i = e.GetEnumerator())
{
while (i.MoveNext())
{
if (p(i.Current))
{
ret++;
}
}
}
return(ret);
}
public static IEnumerable <V> _Select <T, V>(IEnumerable <T> e, SigilFunc <T, V> p)
{
using (var i = e.GetEnumerator())
{
while (i.MoveNext())
{
yield return(p(i.Current));
}
}
}
private static IEnumerable <T> _Where <T>(IEnumerable <T> e, SigilFunc <T, bool> pred)
{
using (var i = e.GetEnumerator())
{
while (i.MoveNext())
{
if (pred(i.Current))
{
yield return(i.Current);
}
}
}
}
public static LinqRoot <T> Where <T>(IEnumerable <T> e, SigilFunc <T, bool> p)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
return(LinqEnumerable <T> .For(_Where(e, p)));
}
public static LinqRoot <T> OrderByDescending <T, V>(IEnumerable <T> e, SigilFunc <T, V> p)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
return(LinqEnumerable <T> .For(_Order(e, p, DescendingComparer <V> .Default)));
}
public static LinqRoot <V> SelectMany <T, V>(IEnumerable <T> e, SigilFunc <T, IEnumerable <V> > p)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
return(LinqEnumerable <V> .For(_SelectMany(e, p)));
}
private static IEnumerable <V> _SelectMany <T, V>(IEnumerable <T> e, SigilFunc <T, IEnumerable <V> > p)
{
using (var i = e.GetEnumerator())
{
while (i.MoveNext())
{
var x = p(i.Current);
using (var j = x.GetEnumerator())
{
while (j.MoveNext())
{
yield return(j.Current);
}
}
}
}
}
public static V Aggregate <T, V>(IEnumerable <T> e, V seed, SigilFunc <V, T, V> a)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (a == null)
{
throw new ArgumentNullException("a");
}
using (var i = e.GetEnumerator())
{
while (i.MoveNext())
{
seed = a(seed, i.Current);
}
}
return(seed);
}
private static IEnumerable <T> _Order <T, V>(IEnumerable <T> e, SigilFunc <T, V> p, IComparer <V> c)
{
var data = ToArray(e);
var length = data.Length;
var indexes = new int[length];
for (int i = 0; i < length; i++)
{
indexes[i] = i;
}
var keys = new V[length];
for (int i = 0; i < length; i++)
{
keys[i] = p(data[i]);
}
return(_QuickSort(data, indexes, keys, c));
}
public static bool Any <T>(IEnumerable <T> e, SigilFunc <T, bool> p)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
var asList = e as IList <T>;
if (asList != null)
{
for (var i = 0; i < asList.Count; i++)
{
if (p(asList[i]))
{
return(true);
}
}
return(false);
}
using (var i = e.GetEnumerator())
{
while (i.MoveNext())
{
if (p(i.Current))
{
return(true);
}
}
}
return(false);
}
public static T FirstOrDefault <T>(IEnumerable <T> e, SigilFunc <T, bool> p)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
using (var i = e.GetEnumerator())
{
while (i.MoveNext())
{
if (p(i.Current))
{
return(i.Current);
}
}
}
return(default(T));
}
public static bool All <T>(IEnumerable <T> e, SigilFunc <T, bool> p)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
using (var i = e.GetEnumerator())
{
while (i.MoveNext())
{
if (!p(i.Current))
{
return(false);
}
}
}
return(true);
}
public bool All(SigilFunc <T, bool> p)
{
return(LinqAlternative.All(InnerEnumerable(), p));
}
public T FirstOrDefault(SigilFunc <T, bool> p)
{
return(LinqAlternative.FirstOrDefault(InnerEnumerable(), p));
}
public LinqDictionary <Key, Value> ToDictionary <Key, Value>(SigilFunc <T, Key> k, SigilFunc <T, Value> v)
{
return(LinqAlternative.ToDictionary(InnerEnumerable(), k, v));
}
public LinqRoot <V> Select <V>(SigilFunc <T, int, V> p)
{
return(LinqAlternative.Select(InnerEnumerable(), p));
}
public int Count(SigilFunc <T, bool> p)
{
return(LinqAlternative.Count(InnerEnumerable(), p));
}
public LinqRoot <T> OrderByDescending <V>(SigilFunc <T, V> p)
{
return(LinqAlternative.OrderByDescending(InnerEnumerable(), p));
}
public LinqRoot <IGrouping <K, T> > GroupBy <K>(SigilFunc <T, K> p)
{
return(LinqAlternative.GroupBy(InnerEnumerable(), p));
}
public LinqRoot <V> SelectMany <V>(SigilFunc <T, LinqRoot <V> > p)
{
return(LinqAlternative.SelectMany(InnerEnumerable(), x => p(x).AsEnumerable()));
}
public LinqRoot <V> SelectMany <V>(SigilFunc <T, IEnumerable <V> > p)
{
return(LinqAlternative.SelectMany(InnerEnumerable(), p));
}
public V Aggregate <V>(V seed, SigilFunc <V, T, V> p)
{
return(LinqAlternative.Aggregate(InnerEnumerable(), seed, p));
}
public LinqRoot <T> Where(SigilFunc <T, bool> p)
{
return(LinqAlternative.Where(InnerEnumerable(), p));
}
public static LinqDictionary <Key, Value> ToDictionary <T, Key, Value>(IEnumerable <T> e, SigilFunc <T, Key> k, SigilFunc <T, Value> v)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (k == null)
{
throw new ArgumentNullException("k");
}
if (v == null)
{
throw new ArgumentNullException("v");
}
var ret = new LinqDictionary <Key, Value>();
using (var i = e.GetEnumerator())
{
while (i.MoveNext())
{
ret.Add(k(i.Current), v(i.Current));
}
}
return(ret);
}
