public static MemoryWhereAtEnumerable <TSource> Where <TSource>(this TSource[] source, PredicateAt <TSource> predicate) => Where(source.AsMemory(), predicate);
public static MemoryWhereIndexEnumerable <TSource> Where <TSource>(this ReadOnlyMemory <TSource> source, PredicateAt <TSource> predicate) { if (predicate is null) { Throw.ArgumentNullException(nameof(predicate)); } return(new MemoryWhereIndexEnumerable <TSource>(source, predicate)); }
public static bool Any <TEnumerable, TEnumerator, TSource>(this TEnumerable source, PredicateAt <TSource> predicate) where TEnumerable : notnull, IValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> { if (predicate is null) { Throw.ArgumentNullException(nameof(predicate)); } using var enumerator = source.GetEnumerator(); checked { for (var index = 0; enumerator.MoveNext(); index++) { if (predicate(enumerator.Current, index)) { return(true); } } } return(false); }
public static bool Any <TSource>(this ImmutableStack <TSource> source, PredicateAt <TSource> predicate) => ValueEnumerable.Any <ValueWrapper <TSource>, ValueWrapper <TSource> .Enumerator, TSource>(new ValueWrapper <TSource>(source), predicate);
static TSource[] ToArray <TSource>(this Span <TSource> source, PredicateAt <TSource> predicate) => ToArray((ReadOnlySpan <TSource>)source, predicate);
public static bool Any <TKey, TValue>(this SortedDictionary <TKey, TValue> source, PredicateAt <KeyValuePair <TKey, TValue> > predicate) => ValueReadOnlyCollectionExtensions.Any <ValueWrapper <TKey, TValue>, SortedDictionary <TKey, TValue> .Enumerator, KeyValuePair <TKey, TValue> >(new ValueWrapper <TKey, TValue>(source), predicate);
static Dictionary <TKey, TElement> ToDictionary <TEnumerable, TEnumerator, TSource, TKey, TElement>(this TEnumerable source, Selector <TSource, TKey> keySelector, NullableSelector <TSource, TElement> elementSelector, IEqualityComparer <TKey>?comparer, PredicateAt <TSource> predicate) where TEnumerable : notnull, IValueEnumerable <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> where TKey : notnull { if (keySelector is null) { Throw.ArgumentNullException(nameof(keySelector)); } if (elementSelector is null) { Throw.ArgumentNullException(nameof(elementSelector)); } using var enumerator = source.GetEnumerator(); checked { var dictionary = new Dictionary <TKey, TElement>(0, comparer); for (var index = 0; enumerator.MoveNext(); index++) { var item = enumerator.Current; if (predicate(item, index)) { dictionary.Add(keySelector(item), elementSelector(item) !); } } return(dictionary); } }
public void ElementAt_Skip_Take_PredicateAt_With_ValidData_Must_Return_Some(int[] source, int skipCount, int takeCount, PredicateAt <int> predicate) { // Arrange var expected = Enumerable .Skip(source, skipCount) .Take(takeCount) .Where(predicate.AsFunc()) .ToList(); for (var index = 0; index < expected.Count; index++) { // Act var result = ArrayExtensions .Skip <int>(source, skipCount) .Take(takeCount) .Where(predicate) .ElementAt(index); // Assert _ = result.Match( value => value.Must().BeEqualTo(expected[index]), () => throw new Exception()); } }
public async ValueTask ForEachAsync_Action_PredicateAt_With_ValidData_Must_Succeed(int[] source, PredicateAt <int> predicate) { // Arrange var wrapped = Wrap.AsAsyncValueEnumerable(source); var result = new List <int>(); var expected = new List <int>(); System.Linq.EnumerableEx.ForEach( System.Linq.Enumerable.Where(source, predicate.AsFunc()), item => expected.Add(item)); // Act await AsyncValueEnumerable .Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync()) .ForEachAsync((item, cancellationToken) => { result.Add(item); return(new ValueTask()); }); // Assert _ = result.Must() .BeEnumerableOf <int>() .BeEqualTo(expected); }
public void All_Skip_Take_PredicateAt_With_ValidData_Must_Succeed(int[] source, int skip, int take, PredicateAt <int> predicate) { // Arrange var(offset, count) = Utils.SkipTake(source.Length, skip, take); var wrapped = new ArraySegment <int>(source, offset, count); var expected = Enumerable .Where(wrapped, predicate.AsFunc()) .Count() == count; // Act var result = ArrayExtensions .All(wrapped, predicate); // Assert _ = result.Must() .BeEqualTo(expected); }
public void ElementAt_Skip_Take_PredicateAt_With_OutOfRange_Must_Return_None(int[] source, int skipCount, int takeCount, PredicateAt <int> predicate) { // Arrange // Act var optionTooSmall = ArrayExtensions .Skip <int>(source, skipCount) .Take(takeCount) .Where(predicate) .ElementAt(-1); var optionTooLarge = ArrayExtensions .Skip <int>(source, skipCount) .Take(takeCount) .Where(predicate) .ElementAt(takeCount); // Assert _ = optionTooSmall.Must() .BeOfType <Option <int> >() .EvaluateTrue(option => option.IsNone); _ = optionTooLarge.Must() .BeOfType <Option <int> >() .EvaluateTrue(option => option.IsNone); }
public static bool All <TSource>(this Span <TSource> source, PredicateAt <TSource> predicate) => All((ReadOnlySpan <TSource>)source, predicate);
static WhereAtEnumerable <TSource> Where <TSource>(this TSource[] source, PredicateAt <TSource> predicate, int skipCount, int takeCount) => new WhereAtEnumerable <TSource>(in source, predicate, skipCount, takeCount);
public static WhereAtEnumerable <TSource> Where <TSource>(this TSource[] source, PredicateAt <TSource> predicate) { if (predicate is null) { Throw.ArgumentNullException(nameof(predicate)); } return(new WhereAtEnumerable <TSource>(in source, predicate, 0, source.Length)); }
public static bool Any <TKey, TValue>(this Dictionary <TKey, TValue> .KeyCollection source, PredicateAt <TKey> predicate) where TKey : notnull => ValueReadOnlyCollectionExtensions.Any <ValueWrapper <TKey, TValue>, Dictionary <TKey, TValue> .KeyCollection.Enumerator, TKey>(new ValueWrapper <TKey, TValue>(source), predicate);
public void Where_With_ValidData_Must_Succeed(int[] source, int skip, int take, PredicateAt <int> predicate) { // Arrange var(offset, count) = Utils.SkipTake(source.Length, skip, take); var wrapped = new ArraySegment <int>(source, offset, count); var expected = Enumerable .Where(wrapped, predicate.AsFunc()); // Act var result = ArrayExtensions .Where(wrapped, predicate); // Assert _ = result.Must() .BeEnumerableOf <int>() .BeEqualTo(expected, testRefStructs: false, testRefReturns: false); _ = result.SequenceEqual(expected).Must().BeTrue(); }
public static ValueEnumerableExtensions.WhereAtEnumerable <ValueWrapper <TKey, TValue>, Dictionary <TKey, TValue> .KeyCollection.Enumerator, TKey> Where <TKey, TValue>( this Dictionary <TKey, TValue> .KeyCollection source, PredicateAt <TKey> predicate) where TKey : notnull => ValueEnumerableExtensions.Where <ValueWrapper <TKey, TValue>, Dictionary <TKey, TValue> .KeyCollection.Enumerator, TKey>(new ValueWrapper <TKey, TValue>(source), predicate);
public async void ElementAtAsync_PredicateAt_With_OutOfRange_Must_Return_None(int[] source, PredicateAt <int> predicate) { // Arrange var wrapped = Wrap.AsAsyncValueEnumerable(source); // Act var optionNegative = await AsyncValueEnumerable .Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync()) .ElementAtAsync(-1); var optionTooLarge = await AsyncValueEnumerable .Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync()) .ElementAtAsync(source.Length); // Assert _ = optionNegative.Must() .BeOfType <Option <int> >() .EvaluateTrue(option => option.IsNone); _ = optionTooLarge.Must() .BeOfType <Option <int> >() .EvaluateTrue(option => option.IsNone); }
public static ValueEnumerableExtensions.WhereAtEnumerable <ValueWrapper <TKey, TValue>, SortedDictionary <TKey, TValue> .Enumerator, KeyValuePair <TKey, TValue> > Where <TKey, TValue>( this SortedDictionary <TKey, TValue> source, PredicateAt <KeyValuePair <TKey, TValue> > predicate) => ValueEnumerableExtensions.Where <ValueWrapper <TKey, TValue>, SortedDictionary <TKey, TValue> .Enumerator, KeyValuePair <TKey, TValue> >(new ValueWrapper <TKey, TValue>(source), predicate);
public async ValueTask ElementAtAsync_PredicateAt_With_ValidData_Must_Return_Some(int[] source, PredicateAt <int> predicate) { // Arrange var wrapped = Wrap.AsAsyncValueEnumerable(source); var expected = System.Linq.Enumerable.ToList( System.Linq.Enumerable.Where(source, predicate.AsFunc())); for (var index = 0; index < expected.Count; index++) { // Act var result = await AsyncValueEnumerable .Where <Wrap.AsyncValueEnumerable <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, predicate.AsAsync()) .ElementAtAsync(index); // Assert _ = result.Match( value => value.Must().BeEqualTo(expected[index]), () => throw new Exception()); } }
static Dictionary <TKey, TSource> ToDictionary <TEnumerable, TEnumerator, TSource, TKey>(this TEnumerable source, NullableSelector <TSource, TKey> keySelector, IEqualityComparer <TKey>?comparer, PredicateAt <TSource> predicate) where TEnumerable : IValueReadOnlyCollection <TSource, TEnumerator> where TEnumerator : struct, IEnumerator <TSource> { if (keySelector is null) { Throw.ArgumentNullException(nameof(keySelector)); } var dictionary = new Dictionary <TKey, TSource>(0, comparer); if (source.Count != 0) { using var enumerator = source.GetEnumerator(); checked { for (var index = 0; enumerator.MoveNext(); index++) { var item = enumerator.Current; if (predicate(item, index)) { dictionary.Add(keySelector(item), item); } } } } return(dictionary); }
public static bool Any <TSource>(this TSource[] source, PredicateAt <TSource> predicate) => Any((ReadOnlySpan <TSource>)source.AsSpan(), predicate);
public static ValueEnumerable.WhereIndexEnumerable <ValueWrapper <TSource>, ValueWrapper <TSource> .Enumerator, TSource> Where <TSource>( this ImmutableStack <TSource> source, PredicateAt <TSource> predicate) => ValueEnumerable.Where <ValueWrapper <TSource>, ValueWrapper <TSource> .Enumerator, TSource>(new ValueWrapper <TSource>(source), predicate);
public void All_Skip_Take_PredicateAt_With_ValidData_Must_Succeed(int[] source, int skipCount, int takeCount, PredicateAt <int> predicate) { // Arrange var wrapped = Wrap.AsValueReadOnlyList(source); var count = System.Linq.Enumerable.Count( System.Linq.Enumerable.Take( System.Linq.Enumerable.Skip(source, skipCount), takeCount)); var expected = System.Linq.Enumerable.Count( System.Linq.Enumerable.Where( System.Linq.Enumerable.Take( System.Linq.Enumerable.Skip(source, skipCount), takeCount), predicate.AsFunc())) == count; // Act var result = ReadOnlyList .Skip <Wrap.ValueReadOnlyList <int>, int>(wrapped, skipCount) .Take(takeCount) .All(predicate); // Assert _ = result.Must() .BeEqualTo(expected); }
static IMemoryOwner <TSource> ToArray <TSource>(this Span <TSource> source, PredicateAt <TSource> predicate, MemoryPool <TSource> pool) => ToArray((ReadOnlySpan <TSource>)source, predicate, pool);
static List <TSource> ToList <TSource>(this ReadOnlySpan <TSource> source, PredicateAt <TSource> predicate) { using var arrayBuilder = ToArrayBuilder(source, predicate, ArrayPool <TSource> .Shared); return(new List <TSource>(arrayBuilder)); }
static Dictionary <TKey, TElement> ToDictionary <TSource, TKey, TElement>(this TSource[] source, NullableSelector <TSource, TKey> keySelector, NullableSelector <TSource, TElement> elementSelector, IEqualityComparer <TKey>?comparer, PredicateAt <TSource> predicate, int skipCount, int takeCount) { var dictionary = new Dictionary <TKey, TElement>(source.Length, comparer); var end = skipCount + takeCount; if (skipCount == 0 && takeCount == source.Length) { for (var index = 0; index < source.Length; index++) { if (predicate(source[index], index)) { dictionary.Add(keySelector(source[index]), elementSelector(source[index])); } } } else { for (var index = skipCount; index < end; index++) { if (predicate(source[index], index)) { dictionary.Add(keySelector(source[index]), elementSelector(source[index])); } } } return(dictionary); }
static Dictionary <TKey, TSource> ToDictionary <TList, TSource, TKey>(this TList source, Selector <TSource, TKey> keySelector, IEqualityComparer <TKey>?comparer, PredicateAt <TSource> predicate, int offset, int count) where TList : notnull, IReadOnlyList <TSource> where TKey : notnull { var dictionary = new Dictionary <TKey, TSource>(source.Count, comparer); var end = offset + count - 1; for (var index = offset; index <= end; index++) { if (predicate(source[index], index)) { dictionary.Add(keySelector(source[index]), source[index]); } } return(dictionary); }
public static SpanWhereRefAtEnumerable <TSource> WhereRef <TSource>(this Span <TSource> source, PredicateAt <TSource> predicate) { if (predicate is null) { Throw.ArgumentNullException(nameof(predicate)); } return(new SpanWhereRefAtEnumerable <TSource>(source, predicate)); }
public static bool All <TSource>(this ReadOnlyMemory <TSource> source, PredicateAt <TSource> predicate) => All(source.Span, predicate);