PHXH
/
UniTask
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

TakeLast

master
neuecc 2020-05-11 14:01:23 +09:00
parent a5f47d4095
commit 8ef7a66081
4 changed files with 199 additions and 772 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/UniTask.NetCore/Linq/SkipLast.cs
View File

@ -138,6 +138,10 @@ namespace Cysharp.Threading.Tasks.Linq
self.completionSource.TrySetResult(false);
}
}
else
{
self.continueNext = false;
}
}
public UniTask DisposeAsync()

936
src/UniTask.NetCore/Linq/TakeLast.cs
View File

@ -1,775 +1,173 @@
namespace Cysharp.Threading.Tasks.Linq
using Cysharp.Threading.Tasks.Internal;
using System;
using System.Collections.Generic;
using System.Threading;
namespace Cysharp.Threading.Tasks.Linq
{
internal sealed class TakeLast
public static partial class UniTaskAsyncEnumerable
{
public static IUniTaskAsyncEnumerable<TSource> TakeLast<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Int32 count)
{
Error.ThrowArgumentNullException(source, nameof(source));
// non take.
if (count <= 0)
{
return Empty<TSource>();
}
return new TakeLast<TSource>(source, count);
}
}
internal sealed class TakeLast<TSource> : IUniTaskAsyncEnumerable<TSource>
{
readonly IUniTaskAsyncEnumerable<TSource> source;
readonly int count;
public TakeLast(IUniTaskAsyncEnumerable<TSource> source, int count)
{
this.source = source;
this.count = count;
}
public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default)
{
return new Enumerator(source, count, cancellationToken);
}
sealed class Enumerator : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
{
static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;
readonly IUniTaskAsyncEnumerable<TSource> source;
readonly int count;
CancellationToken cancellationToken;
IUniTaskAsyncEnumerator<TSource> enumerator;
UniTask<bool>.Awaiter awaiter;
Queue<TSource> queue;
bool iterateCompleted;
bool continueNext;
public Enumerator(IUniTaskAsyncEnumerable<TSource> source, int count, CancellationToken cancellationToken)
{
this.source = source;
this.count = count;
this.cancellationToken = cancellationToken;
}
public TSource Current { get; private set; }
public UniTask<bool> MoveNextAsync()
{
cancellationToken.ThrowIfCancellationRequested();
if (enumerator == null)
{
enumerator = source.GetAsyncEnumerator(cancellationToken);
queue = new Queue<TSource>();
}
completionSource.Reset();
SourceMoveNext();
return new UniTask<bool>(this, completionSource.Version);
}
void SourceMoveNext()
{
if (iterateCompleted)
{
if (queue.Count > 0)
{
Current = queue.Dequeue();
completionSource.TrySetResult(true);
}
else
{
completionSource.TrySetResult(false);
}
return;
}
try
{
LOOP:
awaiter = enumerator.MoveNextAsync().GetAwaiter();
if (awaiter.IsCompleted)
{
continueNext = true;
MoveNextCore(this);
if (continueNext)
{
continueNext = false;
goto LOOP; // avoid recursive
}
}
else
{
awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
}
}
catch (Exception ex)
{
completionSource.TrySetException(ex);
}
}
static void MoveNextCore(object state)
{
var self = (Enumerator)state;
if (self.TryGetResult(self.awaiter, out var result))
{
if (result)
{
if (self.queue.Count < self.count)
{
self.queue.Enqueue(self.enumerator.Current);
if (!self.continueNext)
{
self.SourceMoveNext();
}
}
else
{
self.queue.Dequeue();
self.queue.Enqueue(self.enumerator.Current);
if (!self.continueNext)
{
self.SourceMoveNext();
}
}
}
else
{
self.continueNext = false;
self.iterateCompleted = true;
self.SourceMoveNext();
}
}
else
{
self.continueNext = false;
}
}
public UniTask DisposeAsync()
{
if (enumerator != null)
{
return enumerator.DisposeAsync();
}
return default;
}
}
}
}

2
src/UniTask.NetCoreSandbox/Program.cs
View File

@ -41,7 +41,7 @@ namespace NetCoreSandbox
{
await foreach (var item in UniTaskAsyncEnumerable.Range(1, 10)
.SelectAwait(x => UniTask.Run(() => x))
.SkipLast(6)
.TakeLast(6)

25
src/UniTask.NetCoreTests/Linq/Paging.cs
View File

@ -64,6 +64,31 @@ namespace NetCoreTests.Linq
await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
}
}
[Theory]
[InlineData(0, 0)]
[InlineData(0, 1)]
[InlineData(9, 0)]
[InlineData(9, 1)]
[InlineData(9, 5)]
[InlineData(9, 9)]
[InlineData(9, 15)]
public async Task TakeLast(int collection, int takeCount)
{
var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeLast(takeCount).ToArrayAsync();
var ys = Enumerable.Range(1, collection).TakeLast(takeCount).ToArray();
xs.Should().BeEquivalentTo(ys);
}
[Fact]
public async Task TakeLastException()
{
foreach (var item in UniTaskTestException.Throws())
{
var xs = item.TakeLast(5).ToArrayAsync();
await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
}
}
[Theory]
[InlineData(0, 0)]