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);
}
static LargeArrayBuilder <TSource> ToArrayBuilder <TSource, TPredicate>(ReadOnlySpan <TSource> source, ArrayPool <TSource> arrayPool, bool clearOnDispose, TPredicate predicate)
where TPredicate : struct, IFunction <TSource, bool>
{
var builder = new LargeArrayBuilder <TSource>(arrayPool, clearOnDispose);
foreach (var item in source)
{
if (predicate.Invoke(item))
{
builder.Add(item);
}
}
return(builder);
}
static async ValueTask <LargeArrayBuilder <TResult> > ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource, TResult>(TEnumerable source, AsyncSelector <TSource, TResult> selector, ArrayPool <TResult> arrayPool, CancellationToken cancellationToken)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
Debug.Assert(arrayPool is object);
var builder = new LargeArrayBuilder <TResult>(arrayPool);
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);
}
static LargeArrayBuilder <TSource> ToArrayBuilderAt <TSource, TPredicate>(ReadOnlySpan <TSource> source, ArrayPool <TSource> arrayPool, bool clearOnDispose, TPredicate predicate)
where TPredicate : struct, IFunction <TSource, int, bool>
{
var builder = new LargeArrayBuilder <TSource>(arrayPool, clearOnDispose);
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, TPredicate, TSelector>(TEnumerable source, ArrayPool <TResult> arrayPool, bool clearOnDispose, TPredicate predicate, TSelector selector)
where TEnumerable : IValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IEnumerator <TSource>
where TPredicate : struct, IFunction <TSource, bool>
where TSelector : struct, IFunction <TSource, TResult>
{
var builder = new LargeArrayBuilder <TResult>(arrayPool, clearOnDispose);
using var enumerator = source.GetEnumerator();
while (enumerator.MoveNext())
{
var item = enumerator.Current;
if (predicate.Invoke(item))
{
builder.Add(selector.Invoke(item));
}
}
return(builder);
}
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 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>(TEnumerable source, ArrayPool <TSource> arrayPool, bool clearOnDispose)
where TEnumerable : IValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IEnumerator <TSource>
{
var builder = new LargeArrayBuilder <TSource>(arrayPool, clearOnDispose);
using var enumerator = source.GetEnumerator();
while (enumerator.MoveNext())
{
builder.Add(enumerator.Current);
}
return(builder);
}
static LargeArrayBuilder <TSource> ToArrayBuilderAt <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, int, bool>
{
var builder = new LargeArrayBuilder <TSource>(arrayPool, clearOnDispose);
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);
}
public static ArraySegment <T> RentSliced <T>(this ArrayPool <T> pool, int count) => new ArraySegment <T>(pool.Rent(count), 0, count);
static async ValueTask <ValueMemoryOwner <TResult> > ToArrayAtAsync <TEnumerable, TEnumerator, TSource, TResult, TSelector>(this TEnumerable source, ArrayPool <TResult> pool, CancellationToken cancellationToken, bool clearOnDispose, TSelector selector)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
where TSelector : struct, IAsyncFunction <TSource, int, TResult>
=> (await source.ToArrayBuilderAtAsync <TEnumerable, TEnumerator, TSource, TResult, TSelector>(pool, clearOnDispose, cancellationToken, selector).ConfigureAwait(false)).ToArray(pool, clearOnDispose);
static async ValueTask <ValueMemoryOwner <TSource> > ToArrayAtAsync <TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, ArrayPool <TSource> pool, bool clearOnDispose, CancellationToken cancellationToken, TPredicate predicate)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
where TPredicate : struct, IAsyncFunction <TSource, int, bool>
=> (await source.ToArrayBuilderAtAsync <TEnumerable, TEnumerator, TSource, TPredicate>(pool, clearOnDispose, cancellationToken, predicate).ConfigureAwait(false)).ToArray(pool, clearOnDispose);
public static async ValueTask <ValueMemoryOwner <TSource> > ToArrayAsync <TEnumerable, TEnumerator, TSource>(this TEnumerable source, ArrayPool <TSource> pool, CancellationToken cancellationToken = default, bool clearOnDispose = default)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
=> (await source.ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource>(pool, clearOnDispose, cancellationToken).ConfigureAwait(false)).ToArray(pool, clearOnDispose);
