public SelectEnumerator(IPromiseEnumerator <T> items, Func <T, int, IPromise <E> > predicate)
{
_index = 0;
_current = new NullableResult <E>();
_items = items;
_predicate = predicate;
}
private SelectEnumerator(int index, E current, IPromiseEnumerator <T> items, Func <T, int, IPromise <E> > predicate)
{
_index = index;
_current = new NullableResult <E>(current);
_items = items;
_predicate = predicate;
}
public DistinctEnumerator(IPromiseEnumerator<T> items, HashSet<T> hash, IList<Tuple<T, IPromiseEnumerator<T>>> itemCache, int index)
{
_items = items;
_hash = hash;
_itemCache = itemCache;
_index = index;
}
public static IPromise <IPromiseEnumerator <T> > Each <T>(IPromiseEnumerator <T> items, Action <T, int> action)
{
return(Each(items, (x, index) =>
{
action(x, index);
return items.Factory.StartNew();
}));
}
public static IPromise <List <T> > ToList <T>(IPromiseEnumerator <T> items)
{
return(ReduceAlgorithm.Reduce(items, (prev, current) =>
{
prev.Add(current);
return prev;
}, new List <T>()));
}
public static IPromise <ISet <T> > ToSet <T>(IPromiseEnumerator <T> items, IEqualityComparer <T> comparer)
{
return(ReduceAlgorithm.Reduce(items, (prev, current) =>
{
prev.Add(current);
return prev;
}, (ISet <T>)(new HashSet <T>(comparer))));
}
public static IPromise <IPromiseEnumerator <T> > Advance <T>(this IPromiseEnumerator <T> items, int count)
{
if (count < 1)
{
return(items.Factory.Value(items));
}
return(items.MoveNext().Then(next => next != null ? next.Advance(count - 1) : items.Factory.Value <IPromiseEnumerator <T> >(null)));
}
public MergeEnumerator(PromiseFactory factory, NullableResult <Tuple <Key, Value> > current,
IComparer <Key> comparer, IPromiseEnumerator <Tuple <Key, Value> > left,
IPromiseEnumerator <Tuple <Key, Value> > right)
{
this._left = left;
this._right = right;
this.Factory = factory;
this._current = current;
this._comparer = comparer;
}
public static IPromiseEnumerator <IPromiseGrouping <TKey, TValue> > GroupBy <T, TKey, TValue>(
IPromiseEnumerator <T> items,
Func <T, int, IPromise <TKey> > key,
Func <T, int, IPromise <TValue> > value,
IEqualityComparer <TKey> comparer)
{
var tuples = SelectEnumerator.Create(items, (item, index) => key(item, index).Then(k => value(item, index).Then(v => Tuple.Create(k, v))));
var keys = DistinctEnumerator.Create(SelectEnumerator.Create(tuples, x => x.Item1));
return(SelectEnumerator.Create(keys, k => (IPromiseGrouping <TKey, TValue>)(new PromiseGrouping <T, TKey, TValue>(k, tuples, comparer))));
}
public static IPromise <T> First <T>(IPromiseEnumerator <T> items)
{
return(items.MoveNext().Then(result =>
{
if (result == null)
{
throw new ArgumentOutOfRangeException();
}
return result.Current;
}));
}
public static IPromise <T> Last <T>(IPromiseEnumerator <T> items)
{
return(items.MoveNext().Then(result =>
{
if (result == null)
{
throw new IndexOutOfRangeException();
}
return LastOrDefaultAlgoritm.LastOrDefault(items);
}));
}
public static IPromise <IPromiseEnumerator <T> > DefaultIfEmpty <T>(IPromiseEnumerator <T> items, T defaultValue)
{
return(items.MoveNext().Then(result =>
{
if (result == null)
{
return PromiseEnumerator.Create(items.Factory, new T[] { defaultValue });
}
return items.Factory.Value(items);
}));
}
public static IPromise <bool> Empty <T>(IPromiseEnumerator <T> items)
{
return(items.MoveNext().Then(result =>
{
if (result == null)
{
return true;
}
return false;
}));
}
public static IPromise <T> FirstOrDefault <T>(IPromiseEnumerator <T> items, T defaultValue)
{
return(items.MoveNext().Then(result =>
{
if (result == null)
{
return defaultValue;
}
return result.Current;
}));
}
public static IPromise <IPromiseEnumerator <Result> > GroupJoin <Inner, Outer, Key, Result>(
IPromiseEnumerator <Inner> inner, IPromiseEnumerator <Outer> outer,
Func <Inner, int, IPromise <Key> > innerKey, Func <Outer, int, IPromise <Key> > outerKey,
Func <Outer, IPromiseEnumerable <Inner>, IPromise <Result> > result,
IEqualityComparer <Key> comparer)
{
var innerKeys = SelectEnumerator.Create(inner, (x, i) => innerKey(x, i).Then(v => Tuple.Create(v, x)));
return(inner.Factory.Value(SelectEnumerator.Create(outer, (x, i) => outerKey(x, i).Then(
k => result(x, new PromiseEnumerable <Inner>(
inner.Factory.Value(SelectEnumerator.Create(WhereEnumerator.Create(innerKeys, y => comparer.Equals(y.Item1, k)), y => y.Item2))
))))));
}
private static IPromise <E> Reduce <T, E>(IPromiseEnumerator <T> items, int index, Func <E, T, int, IPromise <E> > fn, E seed)
{
return(items.MoveNext().Then(newItems =>
{
if (newItems == null)
{
return items.Factory.StartNew(seed);
}
else
{
return fn(seed, newItems.Current, index).Then(next => Reduce(newItems, index + 1, fn, next));
}
}));
}
public static IPromise <long> LongCount <T>(IPromiseEnumerator <T> items, Func <T, int, IPromise <bool> > filter)
{
return(ReduceAlgorithm.Reduce <T, long>(items, (prev, current, index) =>
{
return filter(current, index).Then(pick =>
{
if (pick)
{
return prev + 1;
}
return prev;
});
}, 0));
}
private static IPromise <IPromiseEnumerator <Tuple <Key, Value> > > OrderByInternal <Key, Value>
(PromiseFactory factory, IPromiseEnumerator <Tuple <Key, Value> > items, int count, IComparer <Key> comparer)
{
if (count < 2)
{
return(factory.Value(items));
}
int at = count / 2;
return(OrderByInternal(factory, TakeWhileEnumerator.Create(items, at), at, comparer).Then(firstPart =>
items.Advance(at).Then(half => OrderByInternal(factory, half, count - at, comparer)).Then(secondPart =>
(IPromiseEnumerator <Tuple <Key, Value> >)
new MergeEnumerator <Key, Value>(factory, new NullableResult <Tuple <Key, Value> >(), comparer, firstPart, secondPart))));
}
private IPromise<IPromiseEnumerator<T>> FindNext(IPromiseEnumerator<T> items)
{
return items.MoveNext().Then(result =>
{
if (result == null)
{
return null;
}
if (_hash.Contains(result.Current))
{
return FindNext(result);
}
return Factory.Value(result);
});
}
public static IPromise <IPromiseEnumerator <T> > Reverse <T>(IPromiseEnumerator <T> items)
{
return(items.MoveNext().Then(result =>
{
if (result == null)
{
return null;
}
return PromiseEnumerator.Create(items.Factory, new T[] { result.Current }).Then(right =>
{
return Reverse(result).Then(left =>
{
return (IPromiseEnumerator <T>)(ConcatEnumerator.Create(left, right));
});
});
}));
}
public static IPromise <IPromiseEnumerator <T> > Intersect <T>(IPromiseEnumerator <T> left, IPromiseEnumerator <T> right, IEqualityComparer <T> comparer)
{
return(CountAlgorithm.Count(left).Then(leftCount => CountAlgorithm.Count(right).Then(rightCount =>
{
if (leftCount < rightCount)
{
return Tuple.Create(left, right);
}
return Tuple.Create(right, left);
})).Then(result =>
{
var x = result.Item1;
var y = result.Item2;
return ToSetAlgorithm.ToSet(x, comparer).Then(lookup => WhereEnumerator.Create(y, q => lookup.Contains(q, comparer)));
}));
}
public static IPromise <T> Single <T>(IPromiseEnumerator <T> items)
{
return(items.MoveNext().Then(result =>
{
if (result == null)
{
throw new IndexOutOfRangeException();
}
return result.MoveNext().Then(rest =>
{
if (rest != null)
{
throw new InvalidOperationException();
}
return result.Current;
});
}));
}
public static IPromise <T> SingleOrDefault <T>(IPromiseEnumerator <T> items, T defaultValue)
{
return(items.MoveNext().Then(result =>
{
if (result == null)
{
return items.Factory.Value(defaultValue);
}
return result.MoveNext().Then(rest =>
{
if (rest != null)
{
throw new InvalidOperationException();
}
return result.Current;
});
}));
}
public static IPromise <ISet <T> > ToSet <T>(IPromiseEnumerator <T> items)
{
return(ToSet(items, EqualityComparer <T> .Default));
}
public TakeWhileEnumerator(IPromiseEnumerator <T> items, Func <T, int, IPromise <bool> > predicate)
: this(0, items, predicate)
{
}
private TakeWhileEnumerator(int index, IPromiseEnumerator <T> items, Func <T, int, IPromise <bool> > predicate)
{
_index = index;
_items = items;
_predicate = predicate;
}
public static IPromise <IPromiseEnumerator <T> > DefaultIfEmpty <T>(IPromiseEnumerator <T> items)
{
return(DefaultIfEmpty(items, default(T)));
}
public static IPromise <T> First <T>(IPromiseEnumerator <T> items, Func <T, int, IPromise <bool> > predicate)
{
return(First(WhereEnumerator.Create(items, predicate)));
}
public static IPromise <T> Last <T>(IPromiseEnumerator <T> items, Func <T, bool> predicate)
{
return(Last(WhereEnumerator.Create(items, predicate)));
}
public static IPromise <T> Single <T>(IPromiseEnumerator <T> items, Func <T, IPromise <bool> > predicate)
{
return(Single(WhereEnumerator.Create(items, predicate)));
}
