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;
        }
 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));
 }
 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
                ));
 }
Пример #4
0
        public static AsyncTransformExpression <TSource, TOuter> Then <TOuter>([NotNull] AsyncTransformExpression <TSource, TResult> left, [NotNull] AsyncTransformExpression <TResult, TOuter> right)
        {
            if (left == null)
            {
                throw new ArgumentNullException("left");
            }
            if (right == null)
            {
                throw new ArgumentNullException("right");
            }

            if (left.IsIdentity())
            {             // we can optimize the left expression away, since we know that TSource == TResult !
                //note: fool the compiler into believing that TSource == TResult
                return((AsyncTransformExpression <TSource, TOuter>)(object) right);
            }

            if (right.IsIdentity())
            {             // we can optimize the right expression away, since we know that TResult == TOuter !
                return((AsyncTransformExpression <TSource, TOuter>)(object) left);
            }

            if (left.m_transform != null)
            {
                var f = left.m_transform;
                if (right.m_transform != null)
                {
                    var g = right.m_transform;
                    return(new AsyncTransformExpression <TSource, TOuter>((x) => g(f(x))));
                }
                else
                {
                    var g = right.m_asyncTransform;
                    return(new AsyncTransformExpression <TSource, TOuter>((x, ct) => g(f(x), ct)));
                }
            }
            else
            {
                var f = left.m_asyncTransform;
                if (right.m_asyncTransform != null)
                {
                    var g = right.m_asyncTransform;
                    return(new AsyncTransformExpression <TSource, TOuter>(async(x, ct) => await g(await f(x, ct).ConfigureAwait(false), ct).ConfigureAwait(false)));
                }
                else
                {
                    var g = right.m_transform;
                    return(new AsyncTransformExpression <TSource, TOuter>(async(x, ct) => g(await f(x, ct).ConfigureAwait(false))));
                }
            }
        }
        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;
        }
 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));
 }
Пример #7
0
 public AsyncTransformExpression <TSource, TOuter> Then <TOuter>([NotNull] AsyncTransformExpression <TResult, TOuter> expr)
 {
     return(Then <TOuter>(this, expr));
 }