public RateLimitDescriptor(string name, AsyncSelector <int> limit, AsyncSelector <TimeSpan> period, AsyncSelector <string> discriminator)
{
Name = name;
Limit = limit;
Period = period;
Discriminator = discriminator;
}
internal DelegateSet <TResource> SetDelegatesToDefaultsWhereNull
(
Selector <TResource> selector = null,
Inserter <TResource> inserter = null,
Updater <TResource> updater = null,
Deleter <TResource> deleter = null,
Authenticator <TResource> authenticator = null,
Counter <TResource> counter = null,
Validator <TResource> validator = null,
AsyncSelector <TResource> asyncSelector = null,
AsyncInserter <TResource> asyncInserter = null,
AsyncUpdater <TResource> asyncUpdater = null,
AsyncDeleter <TResource> asyncDeleter = null,
AsyncAuthenticator <TResource> asyncAuthenticator = null,
AsyncCounter <TResource> asyncCounter = null
)
{
SyncSelector ??= selector;
SyncInserter ??= inserter;
SyncUpdater ??= updater;
SyncDeleter ??= deleter;
SyncAuthenticator ??= authenticator;
SyncCounter ??= counter;
Validator ??= validator;
AsyncSelector ??= asyncSelector;
AsyncInserter ??= asyncInserter;
AsyncUpdater ??= asyncUpdater;
AsyncDeleter ??= asyncDeleter;
AsyncAuthenticator ??= asyncAuthenticator;
AsyncCounter ??= asyncCounter;
return(this);
}
static WhereSelectEnumerable <TEnumerable, TEnumerator, TSource, TResult> WhereSelect <TEnumerable, TEnumerator, TSource, TResult>(
this TEnumerable source,
AsyncPredicate <TSource> predicate,
AsyncSelector <TSource, TResult> selector)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
=> new WhereSelectEnumerable <TEnumerable, TEnumerator, TSource, TResult>(in source, predicate, selector);
public static SelectEnumerable <TEnumerable, TEnumerator, TSource, TResult> Select <TEnumerable, TEnumerator, TSource, TResult>(
this TEnumerable source,
AsyncSelector <TSource, TResult> selector)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
if (selector is null)
{
Throw.ArgumentNullException(nameof(selector));
}
return(new SelectEnumerable <TEnumerable, TEnumerator, TSource, TResult>(in source, selector));
}
public static RateLimitingOptions Limit(this RateLimitingOptions options, string name, AsyncSelector <int> limit, TimeSpan period, Selector <string> discriminator)
{
return(options.Limit(name, limit, period, discriminator.ToAsync()));
}
public static RateLimitingOptions Limit(this RateLimitingOptions options, string name, int limit, AsyncSelector <TimeSpan> period, AsyncSelector <string> discriminator)
{
return(options.Limit(name, _ => limit, period, discriminator));
}
static async ValueTask <List <TResult> > ToListAsync <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, AsyncSelector <TSource, TResult> selector, CancellationToken cancellationToken)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
var enumerator = source.GetAsyncEnumerator(cancellationToken);
await using (enumerator.ConfigureAwait(false))
{
var list = new List <TResult>();
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
list.Add(await selector(enumerator.Current, cancellationToken).ConfigureAwait(false));
}
return(list);
}
}
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 async ValueTask <Dictionary <TKey, TSource> > ExecuteAsync(TEnumerable source, AsyncSelector <TSource, TKey> keySelector, IEqualityComparer <TKey>?comparer, CancellationToken cancellationToken)
{
var enumerator = source.GetAsyncEnumerator(cancellationToken);
await using (enumerator.ConfigureAwait(false))
{
var dictionary = new Dictionary <TKey, TSource>(0, comparer);
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
var item = enumerator.Current;
dictionary.Add(
await keySelector(item, cancellationToken).ConfigureAwait(false),
item);
}
return(dictionary);
}
}
public Check(string name, AsyncSelector <bool> predicate)
{
Name = name;
Matches = predicate;
}
public RateLimitingOptions Block(string name, AsyncSelector <bool> predicate)
{
Blocked.Add(new Check(name, predicate));
return(this);
}
public async ValueTask AddRangeAsync <TEnumerable, TEnumerator, U>(TEnumerable items, AsyncPredicate <U> predicate, AsyncSelector <U, T> selector, CancellationToken cancellationToken)
where TEnumerable : IAsyncValueEnumerable <U, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <U>
{
Debug.Assert(items is object);
var enumerator = items.GetAsyncEnumerator();
await using (enumerator.ConfigureAwait(false))
{
var destination = _current;
var index = _index;
// Continuously read in items from the enumerator, updating _count
// and _index when we run out of space.
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
cancellationToken.ThrowIfCancellationRequested();
var item = enumerator.Current;
if (await predicate(item, cancellationToken).ConfigureAwait(false))
{
if ((uint)index >= (uint)destination.Length)
{
AddWithBufferAllocation(await selector(item, cancellationToken).ConfigureAwait(false), ref destination, ref index);
}
else
{
destination[index] = await selector(item, cancellationToken).ConfigureAwait(false);
}
index++;
}
}
// Final update to _count and _index.
_count += index - _index;
_index = index;
}
}
public static AsyncSelectorAt <TSource, TTarget> Combine <TSource, TMiddle, TTarget>(AsyncSelector <TSource, TMiddle> first, AsyncSelectorAt <TMiddle, TTarget> second) => async(item, index, cancellation) => await second(await first(item, cancellation).ConfigureAwait(false), index, cancellation).ConfigureAwait(false);
static async ValueTask <List <TResult> > ToListAsync <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, AsyncSelector <TSource, TResult> selector, CancellationToken cancellationToken)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
=> new List <TResult>(await ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource, TResult>(source, selector, ArrayPool <TResult> .Shared, cancellationToken).ConfigureAwait(false));
static async ValueTask <Option <TResult> > FirstAsync <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 enumerator = source.GetAsyncEnumerator(cancellationToken);
await using (enumerator.ConfigureAwait(false))
{
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
var item = enumerator.Current;
if (await predicate(item, cancellationToken).ConfigureAwait(false))
{
return(Option.Some(await selector(item, cancellationToken).ConfigureAwait(false)));
}
}
}
return(Option.None);
}
public static async ValueTask <Option <TResult> > FirstAsync <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, AsyncSelector <TSource, TResult> selector, CancellationToken cancellationToken)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
var enumerator = source.GetAsyncEnumerator(cancellationToken);
await using (enumerator.ConfigureAwait(false))
{
return(await enumerator.MoveNextAsync().ConfigureAwait(false)
? Option.Some(await selector(enumerator.Current, cancellationToken).ConfigureAwait(false))
: Option.None);
}
}
static async ValueTask <IMemoryOwner <TResult> > ToArrayAsync <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, AsyncPredicate <TSource> predicate, AsyncSelector <TSource, TResult> selector, MemoryPool <TResult> pool, CancellationToken cancellationToken)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
=> (await ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource, TResult>(source, predicate, selector, ArrayPool <TResult> .Shared, cancellationToken).ConfigureAwait(false)).ToArray(pool);
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());
}
public RateLimitingOptions Limit(string name, AsyncSelector <int> limit, AsyncSelector <TimeSpan> period, AsyncSelector <string> discriminator)
{
Limited.Add(new RateLimitDescriptor(name, limit, period, discriminator));
return(this);
}
static async ValueTask <bool> ContainsAsync <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, TResult value, IEqualityComparer <TResult>?comparer, AsyncPredicate <TSource> predicate, AsyncSelector <TSource, TResult> selector, CancellationToken cancellationToken)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
var enumerator = source.GetAsyncEnumerator(cancellationToken);
await using (enumerator.ConfigureAwait(false))
{
if (comparer is null)
{
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
if (await predicate(enumerator.Current, cancellationToken).ConfigureAwait(false) &&
EqualityComparer <TResult> .Default.Equals(await selector(enumerator.Current, cancellationToken).ConfigureAwait(false), value))
{
return(true);
}
}
}
else
{
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
if (await predicate(enumerator.Current, cancellationToken).ConfigureAwait(false) &&
comparer.Equals(await selector(enumerator.Current, cancellationToken).ConfigureAwait(false), value))
{
return(true);
}
}
}
}
return(false);
}
public static ValueTask <Dictionary <TKey, TSource> > ToDictionaryAsync <TEnumerable, TEnumerator, TSource, TKey>(this TEnumerable source, AsyncSelector <TSource, TKey> keySelector, IEqualityComparer <TKey>?comparer, CancellationToken cancellationToken = default)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
if (keySelector is null)
{
Throw.ArgumentNullException(nameof(keySelector));
}
cancellationToken.ThrowIfCancellationRequested();
return(ExecuteAsync(source, keySelector, comparer, cancellationToken));
static async ValueTask <Option <TResult> > SingleAsync <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, AsyncPredicate <TSource> predicate, AsyncSelector <TSource, TResult> selector, CancellationToken cancellationToken = default)
where TEnumerable : notnull, IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
{
var option = await GetSingleAsync <TEnumerable, TEnumerator, TSource>(source, predicate, cancellationToken).ConfigureAwait(false);
return(await option.SelectAsync(selector, cancellationToken).ConfigureAwait(false));
}
public static ValueTask <Dictionary <TKey, TSource> > ToDictionaryAsync <TEnumerable, TEnumerator, TSource, TKey>(this TEnumerable source, AsyncSelector <TSource, TKey> keySelector, CancellationToken cancellationToken = default)
where TEnumerable : IAsyncValueEnumerable <TSource, TEnumerator>
where TEnumerator : struct, IAsyncEnumerator <TSource>
=> ToDictionaryAsync <TEnumerable, TEnumerator, TSource, TKey>(source, keySelector, null, cancellationToken);
static async ValueTask <IMemoryOwner <TResult> > ToArrayBuilderAsync <TEnumerable, TEnumerator, TSource, TResult>(this TEnumerable source, AsyncPredicate <TSource> predicate, AsyncSelector <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))
{
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
cancellationToken.ThrowIfCancellationRequested();
var item = enumerator.Current;
if (await predicate(item, cancellationToken).ConfigureAwait(false))
{
builder.Add(await selector(item, cancellationToken).ConfigureAwait(false));
}
}
}
return(builder.ToArray(pool));
}
