SingletonCursor.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Persistence.Serialization;
 
namespace Waher.Persistence.Files.Searching
{
    internal class SingletonCursor<T> : ICursor<T>
    {
        private readonly T value;
        private readonly IObjectSerializer serializer;
        private readonly ObjectSerializer objectSerializer;
        private readonly Guid objectId;
        private bool isCurrent = false;
 
        internal SingletonCursor(T Value, IObjectSerializer Serializer, Guid ObjectId)
        {
            this.value = Value;
            this.serializer = Serializer;
            this.objectSerializer = Serializer as ObjectSerializer;
            this.objectId = ObjectId;
        }
 
        public T Current
        {
            get
            {
                if (this.isCurrent)
                    return this.value;
                else
                    throw new InvalidOperationException("Enumeration not started. Call MoveNext() first.");
            }
        }
 
        public IObjectSerializer CurrentSerializer
        {
            get
            {
                if (this.isCurrent)
                    return this.serializer;
                else
                    throw new InvalidOperationException("Enumeration not started. Call MoveNext() first.");
            }
        }
 
        public bool CurrentTypeCompatible => true;
 
        public Guid CurrentObjectId
        {
            get
            {
                if (this.isCurrent)
                    return this.objectId;
                else
                    throw new InvalidOperationException("Enumeration not started. Call MoveNext() first.");
            }
        }
 
        public void Dispose()
        {
        }
 
        Task<bool> IAsyncEnumerator.MoveNextAsync() => this.MoveNextAsyncLocked();
 
        object IEnumerator.Current => this.Current;
 
        public bool MoveNext() => this.MoveNextAsyncLocked().Result;
 
        public void Reset() => this.isCurrent = false;
 
        public Task<bool> MoveNextAsyncLocked()
        {
            this.isCurrent = !this.isCurrent;
            return Task.FromResult(this.isCurrent);
        }
 
        public Task<bool> MovePreviousAsyncLocked()
        {
            return this.MoveNextAsyncLocked();    // Ordering only in one direction.
        }
 
        public IEnumerator<T> GetEnumerator()
        {
            T[] A = new T[] { this.value };
            return (IEnumerator<T>)A.GetEnumerator();
        }
 
        public bool SameSortOrder(string[] ConstantFields, string[] SortOrder)
        {
            if (SortOrder is null || SortOrder.Length != 1 || this.objectSerializer is null)
                return false;
 
            string s = this.objectSerializer.ObjectIdMemberName;
            return (SortOrder[0] == s || SortOrder[0] == "+" + s);
        }
 
        public bool ReverseSortOrder(string[] ConstantFields, string[] SortOrder)
        {
            if (SortOrder is null || SortOrder.Length != 1 || this.objectSerializer is null)
                return false;
 
            string s = this.objectSerializer.ObjectIdMemberName;
            return (SortOrder[0] == "-" + s);
        }
 
        public Task ContinueAfterLocked(T LastItem)
        {
            this.isCurrent = true;
            return Task.CompletedTask;
        }
 
        public Task ContinueBeforeLocked(T LastItem)
        {
            this.isCurrent = true;
            return Task.CompletedTask;
        }
    }
}