static TResult[] ToArray <TSource, TResult>(this ReadOnlySpan <TSource> source, Predicate <TSource> predicate, Selector <TSource, TResult> selector) { var builder = new LargeArrayBuilder <TResult>(initialize: true); builder.AddRange <TSource>(source, predicate, selector); return(builder.ToArray()); }
static TResult[] ToArray <TSource, TResult>(this TSource[] source, Predicate <TSource> predicate, NullableSelector <TSource, TResult> selector, int skipCount, int takeCount) { var builder = new LargeArrayBuilder <TResult>(initialize: true); builder.AddRange <TSource>(source, predicate, selector, skipCount, takeCount); return(builder.ToArray()); }
static async ValueTask <TSource[]> ToArrayAsync <TSource>(IAsyncEnumerable <TSource> source, CancellationToken cancellationToken) { var builder = new LargeArrayBuilder <TSource>(initialize: true); await builder.AddRangeAsync(source, cancellationToken); return(builder.ToArray()); }
static async ValueTask <LargeArrayBuilder <TSource> > ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource>(TEnumerable source, AsyncPredicateAt <TSource> predicate, ArrayPool <TSource> arrayPool, CancellationToken cancellationToken) where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IAsyncEnumerator <TSource> { Debug.Assert(arrayPool is object); var builder = new LargeArrayBuilder <TSource>(arrayPool); var enumerator = source.GetAsyncEnumerator(); await using (enumerator.ConfigureAwait(false)) { checked { for (var index = 0; await enumerator.MoveNextAsync().ConfigureAwait(false); index++) { cancellationToken.ThrowIfCancellationRequested(); var item = enumerator.Current; if (await predicate(item, index, cancellationToken).ConfigureAwait(false)) { builder.Add(item); } } } } return(builder); }
static TSource[] ToArray <TSource>(this TSource[] source, PredicateAt <TSource> predicate, int skipCount, int takeCount) { var builder = new LargeArrayBuilder <TSource>(initialize: true); builder.AddRange <TSource[]>(source, predicate, skipCount, takeCount); return(builder.ToArray()); }
static async ValueTask <IMemoryOwner <TResult> > ToArrayBuilderAtAsync <TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, TSelector selector, MemoryPool <TResult> pool, CancellationToken cancellationToken) where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IAsyncEnumerator <TSource> where TSelector : struct, IAsyncFunction <TSource, int, TResult> { var builder = new LargeArrayBuilder <TResult>(ArrayPool <TResult> .Shared); var enumerator = source.GetAsyncEnumerator(cancellationToken); try { checked { for (var index = 0; await enumerator.MoveNextAsync().ConfigureAwait(false); index++) { cancellationToken.ThrowIfCancellationRequested(); builder.Add(await selector.InvokeAsync(enumerator.Current, index, cancellationToken).ConfigureAwait(false)); } } } finally { await enumerator.DisposeAsync().ConfigureAwait(false); } return(builder.ToArray(pool)); }
static async ValueTask <LargeArrayBuilder <TResult> > ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource, TResult, TPredicate, TSelector>(this TEnumerable source, TPredicate predicate, TSelector selector, ArrayPool <TResult> arrayPool, CancellationToken cancellationToken) where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IAsyncEnumerator <TSource> where TPredicate : struct, IAsyncFunction <TSource, bool> where TSelector : struct, IAsyncFunction <TSource, TResult> { var builder = new LargeArrayBuilder <TResult>(arrayPool); var enumerator = source.GetAsyncEnumerator(cancellationToken); try { while (await enumerator.MoveNextAsync().ConfigureAwait(false)) { cancellationToken.ThrowIfCancellationRequested(); var item = enumerator.Current; if (await predicate.InvokeAsync(item, cancellationToken).ConfigureAwait(false)) { builder.Add(await selector.InvokeAsync(item, cancellationToken).ConfigureAwait(false)); } } } finally { await enumerator.DisposeAsync().ConfigureAwait(false); } return(builder); }
static async ValueTask <LargeArrayBuilder <TSource> > ToArrayBuilderAtAsync <TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate, ArrayPool <TSource> arrayPool, CancellationToken cancellationToken) where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IAsyncEnumerator <TSource> where TPredicate : struct, IAsyncFunction <TSource, int, bool> { var builder = new LargeArrayBuilder <TSource>(arrayPool); var enumerator = source.GetAsyncEnumerator(cancellationToken); try { checked { for (var index = 0; await enumerator.MoveNextAsync().ConfigureAwait(false); index++) { cancellationToken.ThrowIfCancellationRequested(); var item = enumerator.Current; if (await predicate.InvokeAsync(item, index, cancellationToken).ConfigureAwait(false)) { builder.Add(item); } } } } finally { await enumerator.DisposeAsync().ConfigureAwait(false); } return(builder); }
static TSource[] ToArray <TSource>(this ReadOnlySpan <TSource> source, PredicateAt <TSource> predicate) { var builder = new LargeArrayBuilder <TSource>(initialize: true); builder.AddRange(source, predicate); return(builder.ToArray()); }
static LargeArrayBuilder <TSource> ToArrayBuilderAtRef <TSource, TPredicate>(ReadOnlySpan <TSource> source, TPredicate predicate, ArrayPool <TSource> arrayPool) where TPredicate : struct, IFunctionIn <TSource, int, bool> { var builder = new LargeArrayBuilder <TSource>(arrayPool); for (var index = 0; index < source.Length; index++) { ref readonly var item = ref source[index];
static TResult[] ToArray <TList, TSource, TResult>(this TList source, Predicate <TSource> predicate, Selector <TSource, TResult> selector, int skipCount, int takeCount) where TList : notnull, IReadOnlyList <TSource> { var builder = new LargeArrayBuilder <TResult>(initialize: true); builder.AddRange <TList, TSource>(source, predicate, selector, skipCount, takeCount); return(builder.ToArray()); }
static TSource[] ToArray <TList, TSource>(this TList source, PredicateAt <TSource> predicate, int skipCount, int takeCount) where TList : IReadOnlyList <TSource> { var builder = new LargeArrayBuilder <TSource>(initialize: true); builder.AddRange <TList>(source, predicate, skipCount, takeCount); return(builder.ToArray()); }
static TSource[] ToArray <TEnumerable, TEnumerator, TSource>(this TEnumerable source, PredicateAt <TSource> predicate) where TEnumerable : IValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> { var builder = new LargeArrayBuilder <TSource>(initialize: true); builder.AddRange <TEnumerable, TEnumerator>(source, predicate); return(builder.ToArray()); }
static TResult[] ToArray <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, Predicate <TSource> predicate, NullableSelector <TSource, TResult> selector) where TEnumerable : IValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> { var builder = new LargeArrayBuilder <TResult>(initialize: true); builder.AddRange <TEnumerable, TEnumerator, TSource>(source, predicate, selector); return(builder.ToArray()); }
static async ValueTask <TResult[]> ToArrayAsync <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, AsyncPredicate <TSource> predicate, AsyncSelector <TSource, TResult> selector, CancellationToken cancellationToken) where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IAsyncEnumerator <TSource> { var builder = new LargeArrayBuilder <TResult>(initialize: true); await builder.AddRangeAsync <TEnumerable, TEnumerator, TSource>(source, predicate, selector, cancellationToken).ConfigureAwait(false); return(builder.ToArray()); }
static async ValueTask <TSource[]> ToArrayAsync <TEnumerable, TEnumerator, TSource>(this TEnumerable source, AsyncPredicateAt <TSource> predicate, CancellationToken cancellationToken) where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IAsyncEnumerator <TSource> { var builder = new LargeArrayBuilder <TSource>(initialize: true); await builder.AddRangeAsync <TEnumerable, TEnumerator>(source, predicate, cancellationToken); return(builder.ToArray()); }
public static async ValueTask <TSource[]> ToArrayAsync <TEnumerable, TEnumerator, TSource>(this TEnumerable source, CancellationToken cancellationToken = default) where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IAsyncEnumerator <TSource> { var builder = new LargeArrayBuilder <TSource>(initialize: true); await builder.AddRangeAsync <TEnumerable, TEnumerator>(source, cancellationToken).ConfigureAwait(false); return(builder.ToArray()); }
static LargeArrayBuilder <TSource> ToArrayBuilder <TEnumerable, TEnumerator, TSource>(TEnumerable source, ArrayPool <TSource> arrayPool) where TEnumerable : IValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> { var builder = new LargeArrayBuilder <TSource>(arrayPool); using var enumerator = source.GetEnumerator(); while (enumerator.MoveNext()) { builder.Add(enumerator.Current); } return(builder); }
static LargeArrayBuilder <TSource> ToArrayBuilder <TSource, TPredicate>(ReadOnlySpan <TSource> source, TPredicate predicate, ArrayPool <TSource> arrayPool) where TPredicate : struct, IFunction <TSource, bool> { var builder = new LargeArrayBuilder <TSource>(arrayPool); foreach (var item in source) { if (predicate.Invoke(item)) { builder.Add(item); } } return(builder); }
static LargeArrayBuilder <TResult> ToArrayBuilder <TEnumerable, TEnumerator, TSource, TResult, TSelector>(TEnumerable source, TSelector selector, ArrayPool <TResult> arrayPool) where TEnumerable : IValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> where TSelector : struct, IFunction <TSource, TResult> { var builder = new LargeArrayBuilder <TResult>(arrayPool); using var enumerator = source.GetEnumerator(); while (enumerator.MoveNext()) { builder.Add(selector.Invoke(enumerator.Current)); } return(builder); }
static LargeArrayBuilder <TSource> ToArrayBuilderAt <TSource, TPredicate>(ReadOnlySpan <TSource> source, TPredicate predicate, ArrayPool <TSource> arrayPool) where TPredicate : struct, IFunction <TSource, int, bool> { var builder = new LargeArrayBuilder <TSource>(arrayPool); for (var index = 0; index < source.Length; index++) { var item = source[index]; if (predicate.Invoke(item, index)) { builder.Add(item); } } return(builder); }
static LargeArrayBuilder <TResult> ToArrayBuilder <TEnumerable, TEnumerator, TSource, TResult>(TEnumerable source, NullableSelector <TSource, TResult> selector, ArrayPool <TResult> arrayPool) where TEnumerable : notnull, IValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> { Debug.Assert(arrayPool is object); var builder = new LargeArrayBuilder <TResult>(arrayPool); using var enumerator = source.GetEnumerator(); while (enumerator.MoveNext()) { builder.Add(selector(enumerator.Current)); } return(builder); }
static LargeArrayBuilder <TSource> ToArrayBuilder <TSource>(ReadOnlySpan <TSource> source, Predicate <TSource> predicate, ArrayPool <TSource> arrayPool) { Debug.Assert(arrayPool is object); var builder = new LargeArrayBuilder <TSource>(arrayPool); for (var index = 0; index < source.Length; index++) { if (predicate(source[index])) { builder.Add(source[index]); } } return(builder); }
static LargeArrayBuilder <TResult> ToArrayBuilder <TSource, TResult, TPredicate, TSelector>(ReadOnlySpan <TSource> source, ArrayPool <TResult> arrayPool, bool clearOnDispose, TPredicate predicate, TSelector selector) where TPredicate : struct, IFunction <TSource, bool> where TSelector : struct, IFunction <TSource, TResult> { var builder = new LargeArrayBuilder <TResult>(arrayPool, clearOnDispose); foreach (var item in source) { if (predicate.Invoke(item)) { builder.Add(selector.Invoke(item)); } } return(builder); }
public static async ValueTask <IMemoryOwner <TSource> > ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource>(this TEnumerable source, MemoryPool <TSource> pool, CancellationToken cancellationToken = default) where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IAsyncEnumerator <TSource> { var builder = new LargeArrayBuilder <TSource>(ArrayPool <TSource> .Shared); var enumerator = source.GetAsyncEnumerator(); await using (enumerator.ConfigureAwait(false)) { while (await enumerator.MoveNextAsync().ConfigureAwait(false)) { cancellationToken.ThrowIfCancellationRequested(); builder.Add(enumerator.Current); } } return(builder.ToArray(pool)); }
static LargeArrayBuilder <TResult> ToArrayBuilderAt <TEnumerable, TEnumerator, TSource, TResult, TSelector>(TEnumerable source, ArrayPool <TResult> arrayPool, bool clearOnDispose, TSelector selector) where TEnumerable : IValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> where TSelector : struct, IFunction <TSource, int, TResult> { var builder = new LargeArrayBuilder <TResult>(arrayPool, clearOnDispose); using var enumerator = source.GetEnumerator(); checked { for (var index = 0; enumerator.MoveNext(); index++) { builder.Add(selector.Invoke(enumerator.Current, index)); } } return(builder); }
static LargeArrayBuilder <TSource> ToArrayBuilder <TEnumerable, TEnumerator, TSource, TPredicate>(TEnumerable source, ArrayPool <TSource> arrayPool, bool clearOnDispose, TPredicate predicate) where TEnumerable : IValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> where TPredicate : struct, IFunction <TSource, bool> { var builder = new LargeArrayBuilder <TSource>(arrayPool, clearOnDispose); using var enumerator = source.GetEnumerator(); while (enumerator.MoveNext()) { var item = enumerator.Current; if (predicate.Invoke(item)) { builder.Add(item); } } return(builder); }
////////////////////////////////////////////////////////////////////////////////////////////////// static async ValueTask <TResult[]> ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, AsyncSelector <TSource, TResult> selector, CancellationToken cancellationToken) where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IAsyncEnumerator <TSource> { var builder = new LargeArrayBuilder <TResult>(ArrayPool <TResult> .Shared); var enumerator = source.GetAsyncEnumerator(); await using (enumerator.ConfigureAwait(false)) { while (await enumerator.MoveNextAsync().ConfigureAwait(false)) { cancellationToken.ThrowIfCancellationRequested(); builder.Add(await selector(enumerator.Current, cancellationToken).ConfigureAwait(false)); } } return(builder.ToArray()); }
static LargeArrayBuilder <TSource> ToArrayBuilderAt <TEnumerable, TEnumerator, TSource, TPredicate>(TEnumerable source, TPredicate predicate, ArrayPool <TSource> arrayPool) where TEnumerable : IValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> where TPredicate : struct, IFunction <TSource, int, bool> { var builder = new LargeArrayBuilder <TSource>(arrayPool); using var enumerator = source.GetEnumerator(); for (var index = 0; enumerator.MoveNext(); index++) { var item = enumerator.Current; if (predicate.Invoke(item, index)) { builder.Add(item); } } return(builder); }
static LargeArrayBuilder <TSource> ToArrayBuilder <TEnumerable, TEnumerator, TSource>(TEnumerable source, PredicateAt <TSource> predicate, ArrayPool <TSource> arrayPool) where TEnumerable : notnull, IValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> { Debug.Assert(arrayPool is object); var builder = new LargeArrayBuilder <TSource>(arrayPool); using var enumerator = source.GetEnumerator(); for (var index = 0; enumerator.MoveNext(); index++) { var item = enumerator.Current; if (predicate(item, index)) { builder.Add(item); } } return(builder); }