public FdbDistinctAsyncIterator([NotNull] IFdbAsyncEnumerable <TSource> source, IEqualityComparer <TSource> comparer) : base(source) { Contract.Requires(comparer != null); m_comparer = comparer; }
//TODO: also accept a Func<TSource, CT, Task<bool>> ? public FdbTakeWhileAsyncIterator([NotNull] IFdbAsyncEnumerable <TSource> source, [NotNull] Func <TSource, bool> condition) : base(source) { Contract.Requires(condition != null); m_condition = condition; }
public FdbWhereAsyncIterator([NotNull] IFdbAsyncEnumerable <TSource> source, AsyncFilterExpression <TSource> filter) : base(source) { Contract.Requires(filter != null, "there can be only one kind of filter specified"); m_filter = filter; }
/// <summary>Immediately execute an async action on each element of an async sequence</summary> /// <typeparam name="TSource">Type of elements of the async sequence</typeparam> /// <param name="source">Source async sequence</param> /// <param name="mode">Expected execution mode of the query</param> /// <param name="action">Asynchronous action to perform on each element as it arrives</param> /// <param name="ct">Cancellation token that can be used to cancel the operation</param> /// <returns>Number of items that have been processed</returns> internal static async Task <long> Run <TSource>( [NotNull] IFdbAsyncEnumerable <TSource> source, FdbAsyncMode mode, [NotNull] Func <TSource, Task> action, CancellationToken ct) { ct.ThrowIfCancellationRequested(); //note: we should not use "ConfigureAwait(false)" here because we would like to execute the action in the original synchronization context if possible... long count = 0; using (var iterator = source.GetEnumerator(mode)) { Contract.Assert(iterator != null, "The underlying sequence returned a null async iterator"); while (await iterator.MoveNext(ct)) { ct.ThrowIfCancellationRequested(); await action(iterator.Current); ++count; } } return(count); }
/// <summary>Helper async method to get the first element of an async sequence</summary> /// <typeparam name="TSource">Type of elements of the async sequence</typeparam> /// <param name="source">Source async sequence</param> /// <param name="single">If true, the sequence must contain at most one element</param> /// <param name="orDefault">When the sequence is empty: If true then returns the default value for the type. Otherwise, throws an exception</param> /// <param name="ct">Cancellation token that can be used to cancel the operation</param> /// <returns>Value of the first element of the <param ref="source"/> sequence, or the default value, or an exception (depending on <paramref name="single"/> and <paramref name="orDefault"/></returns> internal static async Task <TSource> Head <TSource>( [NotNull] IFdbAsyncEnumerable <TSource> source, bool single, bool orDefault, CancellationToken ct) { ct.ThrowIfCancellationRequested(); //note: we should not use "ConfigureAwait(false)" here because we would like to execute the action in the original synchronization context if possible... using (var iterator = source.GetEnumerator(FdbAsyncMode.Head)) { Contract.Assert(iterator != null, "The underlying sequence returned a null async iterator"); if (await iterator.MoveNext(ct)) { TSource first = iterator.Current; if (single) { if (await iterator.MoveNext(ct)) { throw new InvalidOperationException("The sequence contained more than one element"); } } return(first); } if (!orDefault) { throw new InvalidOperationException("The sequence was empty"); } return(default(TSource)); } }
/// <summary>Create a new async sequence that will transform an inner async sequence</summary> /// <typeparam name="TSource">Type of elements of the inner async sequence</typeparam> /// <typeparam name="TResult">Type of elements of the outer async sequence</typeparam> /// <param name="source">Source async sequence that will be wrapped</param> /// <param name="factory">Factory method called when the outer sequence starts iterating. Must return an async enumerator</param> /// <returns>New async sequence</returns> internal static FdbAsyncSequence <TSource, TResult> Create <TSource, TResult>( IFdbAsyncEnumerable <TSource> source, Func <IFdbAsyncEnumerator <TSource>, IFdbAsyncEnumerator <TResult> > factory) { return(new FdbAsyncSequence <TSource, TResult>(source, factory)); }
protected OrderedSequence(IFdbAsyncEnumerable <TSource> source, bool descending, OrderedSequence <TSource> parent) { Contract.Requires(source != null); m_source = source; m_descending = descending; m_parent = parent; }
internal static FdbWhereSelectAsyncIterator <TSource, TResult> Map <TSource, TResult>( [NotNull] IFdbAsyncEnumerable <TSource> source, [NotNull] AsyncTransformExpression <TSource, TResult> selector, int?limit = null, int? offset = null) { return(new FdbWhereSelectAsyncIterator <TSource, TResult>(source, filter: null, transform: selector, limit: limit, offset: offset)); }
public FdbSelectManyAsyncIterator([NotNull] IFdbAsyncEnumerable <TSource> source, AsyncTransformExpression <TSource, IEnumerable <TResult> > selector) : base(source) { // Must have at least one, but not both Contract.Requires(selector != null); m_selector = selector; }
/// <summary>Create a new batching iterator</summary> /// <param name="source">Source sequence of items that must be batched by waves</param> /// <param name="batchSize">Maximum size of a batch to return down the line</param> public FdbBatchingAsyncIterator(IFdbAsyncEnumerable <TInput> source, int batchSize) : base(source) { Contract.Requires(batchSize > 0); m_source = source; m_batchSize = batchSize; }
public static FdbQueryAsyncEnumerableExpression <T> Sequence <T>([NotNull] IFdbAsyncEnumerable <T> source) { if (source == null) { throw new ArgumentNullException("source"); } return(new FdbQueryAsyncEnumerableExpression <T>(source)); }
protected readonly OrderedSequence <TSource> m_parent; // null if primary sort key public OrderedSequence(IFdbAsyncEnumerable <TSource> source, IComparer <TSource> comparer, bool descending, OrderedSequence <TSource> parent) { Contract.Requires(source != null); m_source = source; m_descending = descending; m_comparer = comparer ?? Comparer <TSource> .Default; m_parent = parent; }
/// <summary>Sequence the return only the elements of <paramref name="first"/> that are not in <paramref name="second"/></summary> /// <typeparam name="TResult">Type of the results of the query</typeparam> /// <param name="first">Fisrt query that contains the elements that could be in the result</param> /// <param name="second">Second query that contains the elements that cannot be in the result</param> /// <param name="comparer">Instance used to compare elements</param> /// <returns>Async query that returns only the elements that are in <paramref name="first"/>, and not in <paramref name="second"/></returns> public static IFdbAsyncEnumerable <TResult> Except <TResult>(this IFdbAsyncEnumerable <TResult> first, IFdbAsyncEnumerable <TResult> second, IComparer <TResult> comparer = null) { return(new FdbExceptIterator <TResult, TResult, TResult>( new[] { first, second }, null, TaskHelpers.Cache <TResult> .Identity, TaskHelpers.Cache <TResult> .Identity, comparer )); }
public static IFdbAsyncEnumerable <TResult> Intersect <TKey, TResult>(this IFdbAsyncEnumerable <TResult> first, IFdbAsyncEnumerable <TResult> second, Func <TResult, TKey> keySelector, IComparer <TKey> keyComparer = null) { return(new FdbIntersectIterator <TResult, TKey, TResult>( new[] { first, second }, null, keySelector, TaskHelpers.Cache <TResult> .Identity, keyComparer )); }
internal static FdbSelectManyAsyncIterator <TSource, TCollection, TResult> Flatten <TSource, TCollection, TResult>( [NotNull] IFdbAsyncEnumerable <TSource> source, [NotNull] AsyncTransformExpression <TSource, IEnumerable <TCollection> > collectionSelector, [NotNull] Func <TSource, TCollection, TResult> resultSelector) { return(new FdbSelectManyAsyncIterator <TSource, TCollection, TResult>( source, collectionSelector, resultSelector )); }
public static IFdbAsyncEnumerable <TResult> Except <TResult>([NotNull] this IFdbAsyncEnumerable <TResult> first, [NotNull] IFdbAsyncEnumerable <TResult> second, IComparer <TResult> comparer = null) { Contract.NotNull(first, nameof(first)); Contract.NotNull(second, nameof(second)); return(new FdbExceptIterator <TResult, TResult, TResult>( new[] { first, second }, null, (x) => x, (x) => x, comparer )); }
public FdbParallelSelectAsyncIterator( [NotNull] IFdbAsyncEnumerable <TSource> source, [NotNull] Func <TSource, CancellationToken, Task <TResult> > taskSelector, [NotNull] FdbParallelQueryOptions options ) : base(source) { Contract.Requires(taskSelector != null && options != null); m_taskSelector = taskSelector; m_options = options; }
public static IFdbAsyncEnumerable <TResult> Intersect <TKey, TResult>([NotNull] this IFdbAsyncEnumerable <TResult> first, IFdbAsyncEnumerable <TResult> second, Func <TResult, TKey> keySelector, IComparer <TKey> keyComparer = null) { Contract.NotNull(first, nameof(first)); Contract.NotNull(second, nameof(second)); return(new FdbIntersectIterator <TResult, TKey, TResult>( new[] { first, second }, null, keySelector, (x) => x, keyComparer )); }
public FdbWhereSelectAsyncIterator( [NotNull] IFdbAsyncEnumerable <TSource> source, AsyncFilterExpression <TSource> filter, AsyncTransformExpression <TSource, TResult> transform, int?limit, int?offset ) : base(source) { Contract.Requires(transform != null); // must do at least something Contract.Requires((limit ?? 0) >= 0 && (offset ?? 0) >= 0); // bounds cannot be negative m_filter = filter; m_transform = transform; m_limit = limit; m_offset = offset; }
protected FdbAsyncFilterIterator([NotNull] IFdbAsyncEnumerable <TSource> source) { Contract.Requires(source != null); m_source = source; }
/// <summary>Create a new batching iterator</summary> /// <param name="source">Source sequence of items that must be batched by waves</param> /// <param name="prefetchCount">Maximum size of a batch to return down the line</param> public FdbPrefetchingAsyncIterator(IFdbAsyncEnumerable <TInput> source, int prefetchCount) : base(source) { Contract.Requires(prefetchCount > 0); m_prefetchCount = prefetchCount; }
internal static FdbTakeWhileAsyncIterator <TResult> Limit <TResult>( [NotNull] IFdbAsyncEnumerable <TResult> source, [NotNull] Func <TResult, bool> condition) { return(new FdbTakeWhileAsyncIterator <TResult>(source, condition)); }
internal static FdbWhereSelectAsyncIterator <TResult, TResult> Limit <TResult>( [NotNull] IFdbAsyncEnumerable <TResult> source, int limit) { return(new FdbWhereSelectAsyncIterator <TResult, TResult>(source, filter: null, transform: new AsyncTransformExpression <TResult, TResult>(TaskHelpers.Cache <TResult> .Identity), limit: limit, offset: null)); }
internal static FdbWhereAsyncIterator <TResult> Filter <TResult>( [NotNull] IFdbAsyncEnumerable <TResult> source, [NotNull] AsyncFilterExpression <TResult> filter) { return(new FdbWhereAsyncIterator <TResult>(source, filter)); }
internal static FdbSelectManyAsyncIterator <TSource, TResult> Flatten <TSource, TResult>( [NotNull] IFdbAsyncEnumerable <TSource> source, [NotNull] AsyncTransformExpression <TSource, IEnumerable <TResult> > selector) { return(new FdbSelectManyAsyncIterator <TSource, TResult>(source, selector)); }
internal FdbQueryAsyncEnumerableExpression(IFdbAsyncEnumerable <T> source) { Contract.Requires(source != null); this.Source = source; }
public FdbObserverIterator(IFdbAsyncEnumerable <TSource> source, AsyncObserverExpression <TSource> observer) : base(source) { Contract.Requires(observer != null); m_observer = observer; }
/// <summary>Create a new batching iterator</summary> /// <param name="source">Source sequence of items that must be batched by waves</param> /// <param name="maxWindowSize">Maximum size of a batch to return down the line</param> public FdbWindowingAsyncIterator(IFdbAsyncEnumerable <TInput> source, int maxWindowSize) : base(source) { Contract.Requires(maxWindowSize > 0); m_maxWindowSize = maxWindowSize; }
public FdbAsyncSequence([NotNull] IFdbAsyncEnumerable <TSource> source, [NotNull] Func <IFdbAsyncEnumerator <TSource>, IFdbAsyncEnumerator <TResult> > factory) { Contract.Requires(source != null && factory != null); this.Source = source; this.Factory = factory; }