UnionCursor.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Persistence.Filters;
using Waher.Persistence.Serialization;
 
namespace Waher.Persistence.Files.Searching
{
    internal class UnionCursor<T> : ICursor<T>
    {
        private readonly Dictionary<Guid, bool> returned = new Dictionary<Guid, bool>();
        private ICursor<T> currentCursor;
        private readonly Filter[] childFilters;
        private readonly ObjectBTreeFile file;
        private int currentCursorPosition = 0;
        private readonly int nrCursors;
 
        public UnionCursor(Filter[] ChildFilters, ObjectBTreeFile File)
        {
            this.childFilters = ChildFilters;
            this.nrCursors = this.childFilters.Length;
            this.file = File;
            this.currentCursor = null;
        }
 
        public T Current => this.CurrentCursor.Current;
 
        private ICursor<T> CurrentCursor
        {
            get
            {
                if (this.currentCursor is null)
                    throw new InvalidOperationException("Enumeration not started or has already ended.");
                else
                    return this.currentCursor;
            }
        }
 
        public IObjectSerializer CurrentSerializer => this.CurrentCursor.CurrentSerializer;
 
        public bool CurrentTypeCompatible => this.CurrentCursor.CurrentTypeCompatible;
 
        public Guid CurrentObjectId => this.CurrentCursor.CurrentObjectId;
 
        public void Dispose()
        {
            this.currentCursor = null;
        }
 
        Task<bool> IAsyncEnumerator.MoveNextAsync() => this.MoveNextAsyncLocked();
 
        object IEnumerator.Current => this.Current;
 
        public bool MoveNext() => this.MoveNextAsyncLocked().Result;
 
        public void Reset()
        {
            this.currentCursor = null;
            this.currentCursorPosition = 0;
        }
 
        public async Task<bool> MoveNextAsyncLocked()
        {
            Guid ObjectId;
 
            while (true)
            {
                if (this.currentCursor is null)
                {
                    if (this.currentCursorPosition >= this.nrCursors)
                        return false;
 
                    this.currentCursor = await this.file.ConvertFilterToCursorLocked<T>(this.childFilters[this.currentCursorPosition++], null, true);
                }
 
                if (!await this.currentCursor.MoveNextAsyncLocked())
                {
                    this.currentCursor = null;
                    continue;
                }
 
                if (!this.currentCursor.CurrentTypeCompatible)
                    continue;
 
                ObjectId = this.currentCursor.CurrentObjectId;
                if (this.returned.ContainsKey(ObjectId))
                    continue;
 
                this.returned[ObjectId] = true;
                return true;
            }
        }
 
        public Task<bool> MovePreviousAsyncLocked()
        {
            return this.MoveNextAsyncLocked();    // Union operator not ordered.
        }
 
        public bool SameSortOrder(string[] ConstantFields, string[] SortOrder)
        {
            return false;
        }
 
        public bool ReverseSortOrder(string[] ConstantFields, string[] SortOrder)
        {
            return false;
        }
 
        public Task ContinueAfterLocked(T LastItem)
        {
            throw new NotSupportedException("Paginated search is not supported for union queries.");
        }
 
        public Task ContinueBeforeLocked(T LastItem)
        {
            throw new NotSupportedException("Paginated search is not supported for union queries.");
        }
    }
}