PaginatedEnumerator.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Events;
 
namespace Waher.Persistence
{
    public class PaginatedEnumerator<T> : IAsyncEnumerator<T>, IDisposableAsync
        where T : class
    {
        private readonly IPage<T> firstPage;
        private IPage<T> currentPage;
        private IEnumerator<T> currentPageEnumerator;
        private IAsyncEnumerator currentPageEnumeratorAsync;
 
        public PaginatedEnumerator(IPage<T> FirstPage)
        {
            this.currentPage = this.firstPage = FirstPage;
            this.currentPageEnumerator = this.currentPage.Items.GetEnumerator();
            this.currentPageEnumeratorAsync = this.currentPageEnumerator as IAsyncEnumerator;
        }
 
        public PaginatedEnumerator(IEnumerable<T> FixedSetOfItems)
        {
            this.firstPage = null;
            this.currentPage = null;
            this.currentPageEnumerator = FixedSetOfItems.GetEnumerator();
            this.currentPageEnumeratorAsync = this.currentPageEnumerator as IAsyncEnumerator;
        }
 
        public T Current => this.currentPageEnumerator.Current;
 
        object IEnumerator.Current => this.currentPageEnumerator.Current;
 
        [Obsolete("Use DisposeAsync() instead.")]
        public void Dispose()
        {
            this.DisposeAsync().Wait();
        }
 
        public async Task DisposeAsync()
        {
            if (this.currentPage is IDisposableAsync DisposableAsync)
                await DisposableAsync.DisposeAsync();
            else if (this.currentPage is IDisposable Disposable)
                Disposable.Dispose();
 
            if (this.currentPageEnumerator is IDisposableAsync DisposableAsync2)
                await DisposableAsync2.DisposeAsync();
            else
                this.currentPageEnumerator.Dispose();
        }
 
        public bool MoveNext()
        {
            while (true)
            {
                if (this.currentPageEnumerator.MoveNext())
                    return true;
 
                if (this.currentPage is null)
                    return false;
 
                if (!this.currentPage.More)
                    return false;
 
                this.currentPage = Database.FindNext(this.currentPage).Result;
                this.currentPageEnumerator = this.currentPage.Items.GetEnumerator();
                this.currentPageEnumeratorAsync = this.currentPageEnumerator as IAsyncEnumerator;
            }
        }
 
        public async Task<bool> MoveNextAsync()
        {
            while (true)
            {
                if (await this.MoveNextOnCurrentPage())
                    return true;
 
                if (this.currentPage is null)
                    return false;
 
                if (!this.currentPage.More)
                    return false;
 
                this.currentPage = await Database.FindNext(this.currentPage);
                this.currentPageEnumerator = this.currentPage.Items.GetEnumerator();
                this.currentPageEnumeratorAsync = this.currentPageEnumerator as IAsyncEnumerator;
            }
        }
 
        private Task<bool> MoveNextOnCurrentPage()
        {
            if (this.currentPageEnumeratorAsync is null)
                return Task.FromResult(this.currentPageEnumerator.MoveNext());
            else
                return this.currentPageEnumeratorAsync.MoveNextAsync();
        }
 
        public void Reset()
        {
            if (this.firstPage is null)
                this.currentPageEnumerator.Reset();
            else
            {
                this.currentPage = this.firstPage;
                this.currentPageEnumerator = this.currentPage.Items.GetEnumerator();
                this.currentPageEnumeratorAsync = this.currentPageEnumerator as IAsyncEnumerator;
            }
        }
    }
}