PagedCursor.cs

using System;
using System.Collections;
using System.Threading.Tasks;
using Waher.Persistence.Serialization;
 
namespace Waher.Persistence.Files.Searching
{
    internal class PagesCursor<T> : ICursor<T>
    {
        private int offset;
        private int maxCount;
        private readonly ICursor<T> cursor;
 
        internal PagesCursor(int Offset, int MaxCount, ICursor<T> Cursor)
        {
            this.offset = Offset;
            this.maxCount = MaxCount;
            this.cursor = Cursor;
        }
 
        public T Current => this.cursor.Current;
 
        public IObjectSerializer CurrentSerializer => this.cursor.CurrentSerializer;
 
        public bool CurrentTypeCompatible => this.cursor.CurrentTypeCompatible;
 
        public Guid CurrentObjectId => this.cursor.CurrentObjectId;
 
        public void Dispose()
        {
        }
 
        Task<bool> IAsyncEnumerator.MoveNextAsync() => this.MoveNextAsyncLocked();
 
        object IEnumerator.Current => this.Current;
 
        public bool MoveNext() => this.MoveNextAsyncLocked().Result;
 
        public void Reset() => this.cursor.Reset();
 
        public async Task<bool> MoveNextAsyncLocked()
        {
            while (true)
            {
                if (this.maxCount <= 0)
                    return false;
 
                if (!await this.cursor.MoveNextAsyncLocked())
                    return false;
 
                if (!this.cursor.CurrentTypeCompatible)
                    continue;
 
                if (this.offset > 0)
                {
                    this.offset--;
                    continue;
                }
 
                this.maxCount--;
                return true;
            }
        }
 
        public Task<bool> MovePreviousAsyncLocked()
        {
            return this.MoveNextAsyncLocked();    // Ordering only in one direction.
        }
 
        public bool SameSortOrder(string[] ConstantFields, string[] SortOrder)
        {
            return this.cursor.SameSortOrder(ConstantFields, SortOrder);
        }
 
        public bool ReverseSortOrder(string[] ConstantFields, string[] SortOrder)
        {
            return this.cursor.ReverseSortOrder(ConstantFields, SortOrder);
        }
 
        public Task ContinueAfterLocked(T LastItem)
        {
            return this.cursor.ContinueAfterLocked(LastItem);
        }
 
        public Task ContinueBeforeLocked(T LastItem)
        {
            return this.cursor.ContinueBeforeLocked(LastItem);
        }
    }
}