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 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 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 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 async ValueTask <TSource[]> ToArrayBuilderAsync <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>(ArrayPool <TSource> .Shared);
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.ToArray());
}
static async ValueTask <IMemoryOwner <TSource> > ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate, MemoryPool <TSource> pool, CancellationToken cancellationToken)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
where TPredicate : struct, IAsyncFunction <TSource, bool>
{
var builder = new LargeArrayBuilder <TSource>(ArrayPool <TSource> .Shared);
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(item);
}
}
}
finally
{
await enumerator.DisposeAsync().ConfigureAwait(false);
}
return(builder.ToArray(pool));
}
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());
}
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 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 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());
}
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 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());
}
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 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 T[] ToArray <T>(IEnumerable <T> source)
{
switch (source)
{
case ICollection <T> collection:
var count = collection.Count;
if (count == 0)
{
return(System.Array.Empty <T>());
}
var buffer = new T[count];
collection.CopyTo(buffer, 0);
return(buffer);
default:
var builder = new LargeArrayBuilder <T>(initialize: true);
builder.AddRange(source);
return(builder.ToArray());
}
}
public static async ValueTask <TSource[]> ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource>(this TEnumerable source, CancellationToken cancellationToken = default)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
var builder = new LargeArrayBuilder <TSource>(ArrayPool <TSource> .Shared);
var enumerator = source.GetAsyncEnumerator(cancellationToken);
try
{
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
cancellationToken.ThrowIfCancellationRequested();
builder.Add(enumerator.Current);
}
}
finally
{
await enumerator.DisposeAsync().ConfigureAwait(false);
}
return(builder.ToArray());
}
static async ValueTask <IMemoryOwner <TResult> > ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, AsyncSelectorAt <TSource, TResult> selector, MemoryPool <TResult> pool, 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))
{
checked
{
for (var index = 0; await enumerator.MoveNextAsync().ConfigureAwait(false); index++)
{
cancellationToken.ThrowIfCancellationRequested();
builder.Add(await selector(enumerator.Current, index, cancellationToken).ConfigureAwait(false));
}
}
}
return(builder.ToArray(pool));
}
public static TSource[] ToArray <TEnumerable, TEnumerator, TSource>(this TEnumerable source)
where TEnumerable : IValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IEnumerator <TSource>
{
switch (source)
{
case ICollection <TSource> collection:
var count = collection.Count;
if (count == 0)
{
return(Array.Empty <TSource>());
}
var buffer = new TSource[count];
collection.CopyTo(buffer, 0);
return(buffer);
default:
var builder = new LargeArrayBuilder <TSource>(initialize: true);
builder.AddRange <TEnumerable, TEnumerator>(source);
return(builder.ToArray());
}
}