RangesCursor.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 RangesCursor<T> : ICursor<T>
    {
        private readonly RangeInfo[] ranges;
        private readonly IndexBTreeFile index;
        private readonly IApplicableFilter[] additionalfilters;
        private RangeInfo[] currentLimits;
        private ICursor<T> currentRange;
        private KeyValuePair<string, IApplicableFilter>[] startRangeFilters;
        private KeyValuePair<string, IApplicableFilter>[] endRangeFilters;
        private readonly FilesProvider provider;
        private readonly int nrRanges;
        private int limitsUpdatedAt;
        private readonly bool firstAscending;
        private readonly bool[] ascending;
 
        public RangesCursor(IndexBTreeFile Index, RangeInfo[] Ranges, IApplicableFilter[] AdditionalFilters, FilesProvider Provider)
        {
            this.index = Index;
            this.ranges = Ranges;
            this.additionalfilters = AdditionalFilters;
            this.currentRange = null;
            this.ascending = Index.Ascending;
            this.firstAscending = this.ascending[0];
            this.nrRanges = this.ranges.Length;
            this.provider = Provider;
 
            this.Reset();
        }
 
        public T Current => this.CurrentCursor.Current;
 
        private ICursor<T> CurrentCursor
        {
            get
            {
                if (this.currentRange is null)
                    throw new InvalidOperationException("Enumeration not started or has already ended.");
                else
                    return this.currentRange;
            }
        }
 
        public IObjectSerializer CurrentSerializer => this.CurrentCursor.CurrentSerializer;
 
        public bool CurrentTypeCompatible => this.CurrentCursor.CurrentTypeCompatible;
 
        public Guid CurrentObjectId => this.CurrentCursor.CurrentObjectId;
 
        public void Dispose()
        {
            this.currentRange = null;
        }
 
        Task<bool> IAsyncEnumerator.MoveNextAsync() => this.MoveNextAsyncLocked();
 
        object IEnumerator.Current => this.Current;
 
        public bool MoveNext() => this.MoveNextAsyncLocked().Result;
 
        public void Reset()
        {
            int i;
 
            this.currentLimits = new RangeInfo[this.nrRanges];
            this.currentRange = null;
 
            for (i = 0; i < this.nrRanges; i++)
                this.currentLimits[i] = this.ranges[i].Copy();
        }
 
        public async Task<bool> MoveNextAsyncLocked()
        {
            int i;
 
            while (true)
            {
                if (this.currentRange is null)
                {
                    List<KeyValuePair<string, object>> SearchParameters = new List<KeyValuePair<string, object>>();
                    List<KeyValuePair<string, IApplicableFilter>> StartFilters = null;
                    List<KeyValuePair<string, IApplicableFilter>> EndFilters = null;
                    RangeInfo Range;
                    object Value;
 
                    for (i = 0; i < this.nrRanges; i++)
                    {
                        Range = this.currentLimits[i];
 
                        if (Range.IsPoint)
                        {
                            if (EndFilters is null)
                                EndFilters = new List<KeyValuePair<string, IApplicableFilter>>();
 
                            SearchParameters.Add(new KeyValuePair<string, object>(Range.FieldName, Range.Point));
                            EndFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldEqualTo(Range.FieldName, Range.Point)));
                        }
                        else
                        {
                            if (Range.HasMin)
                            {
                                Value = Range.Min;
 
                                if (this.ascending[i])
                                {
                                    if (StartFilters is null)
                                        StartFilters = new List<KeyValuePair<string, IApplicableFilter>>();
 
                                    if (Range.MinInclusive)
                                        StartFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldGreaterOrEqualTo(Range.FieldName, Value)));
                                    else
                                    {
                                        StartFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldGreaterThan(Range.FieldName, Value)));
 
                                        if (!Comparison.Increment(ref Value))
                                            return false;
                                    }
 
                                    SearchParameters.Add(new KeyValuePair<string, object>(Range.FieldName, Value));
                                }
                                else
                                {
                                    if (EndFilters is null)
                                        EndFilters = new List<KeyValuePair<string, IApplicableFilter>>();
 
                                    if (Range.MinInclusive)
                                        EndFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldGreaterOrEqualTo(Range.FieldName, Value)));
                                    else
                                        EndFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldGreaterThan(Range.FieldName, Value)));
                                }
                            }
 
                            if (Range.HasMax)
                            {
                                Value = Range.Max;
 
                                if (!this.ascending[i])
                                {
                                    if (StartFilters is null)
                                        StartFilters = new List<KeyValuePair<string, IApplicableFilter>>();
 
                                    if (Range.MaxInclusive)
                                        StartFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldLesserOrEqualTo(Range.FieldName, Value)));
                                    else
                                    {
                                        StartFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldLesserThan(Range.FieldName, Value)));
 
                                        if (!Comparison.Decrement(ref Value))
                                            return false;
                                    }
 
                                    SearchParameters.Add(new KeyValuePair<string, object>(Range.FieldName, Value));
                                }
                                else
                                {
                                    if (EndFilters is null)
                                        EndFilters = new List<KeyValuePair<string, IApplicableFilter>>();
 
                                    if (Range.MaxInclusive)
                                        EndFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldLesserOrEqualTo(Range.FieldName, Value)));
                                    else
                                        EndFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldLesserThan(Range.FieldName, Value)));
                                }
                            }
                        }
                    }
 
                    if (this.firstAscending)
                        this.currentRange = await this.index.FindFirstGreaterOrEqualToLocked<T>(SearchParameters.ToArray());
                    else
                        this.currentRange = await this.index.FindLastLesserOrEqualToLocked<T>(SearchParameters.ToArray());
 
                    this.startRangeFilters = StartFilters?.ToArray();
                    this.endRangeFilters = EndFilters?.ToArray();
                    this.limitsUpdatedAt = this.nrRanges;
                }
 
                if (!await this.currentRange.MoveNextAsyncLocked())
                {
                    this.currentRange = null;
 
                    if (this.limitsUpdatedAt >= this.nrRanges)
                        return false;
 
                    continue;
                }
 
                if (!this.currentRange.CurrentTypeCompatible)
                    continue;
 
                object CurrentValue = this.currentRange.Current;
                IObjectSerializer CurrentSerializer = this.currentRange.CurrentSerializer;
                string OutOfStartRangeField = null;
                string OutOfEndRangeField = null;
                bool Ok = true;
                bool Smaller;
 
                if (!(this.additionalfilters is null))
                {
                    foreach (IApplicableFilter Filter in this.additionalfilters)
                    {
                        if (!await Filter.AppliesTo(CurrentValue, CurrentSerializer, this.provider))
                        {
                            Ok = false;
                            break;
                        }
                    }
                }
 
                if (!(this.startRangeFilters is null))
                {
                    foreach (KeyValuePair<string, IApplicableFilter> Filter in this.startRangeFilters)
                    {
                        if (!await Filter.Value.AppliesTo(CurrentValue, CurrentSerializer, this.provider))
                        {
                            OutOfStartRangeField = Filter.Key;
                            Ok = false;
                            break;
                        }
                    }
                }
 
                if (!(this.endRangeFilters is null) && OutOfStartRangeField is null)
                {
                    foreach (KeyValuePair<string, IApplicableFilter> Filter in this.endRangeFilters)
                    {
                        if (!await Filter.Value.AppliesTo(CurrentValue, CurrentSerializer, this.provider))
                        {
                            OutOfEndRangeField = Filter.Key;
                            Ok = false;
                            break;
                        }
                    }
                }
 
                for (i = 0; i < this.limitsUpdatedAt; i++)
                {
                    object FieldValue = await CurrentSerializer.TryGetFieldValue(this.ranges[i].FieldName, CurrentValue);
 
                    if (!(FieldValue is null))
                    {
                        if (this.ascending[i])
                        {
                            if (this.currentLimits[i].SetMin(FieldValue, !(OutOfStartRangeField is null), out Smaller) && Smaller)
                            {
                                i++;
                                this.limitsUpdatedAt = i;
 
                                while (i < this.nrRanges)
                                {
                                    this.ranges[i].CopyTo(this.currentLimits[i]);
                                    i++;
                                }
                            }
                        }
                        else
                        {
                            if (this.currentLimits[i].SetMax(FieldValue, !(OutOfStartRangeField is null), out Smaller) && Smaller)
                            {
                                i++;
                                this.limitsUpdatedAt = i;
 
                                while (i < this.nrRanges)
                                {
                                    this.ranges[i].CopyTo(this.currentLimits[i]);
                                    i++;
                                }
                            }
                        }
                    }
                }
 
                if (Ok)
                    return true;
                else if (!(OutOfStartRangeField is null) || !(OutOfEndRangeField is null))
                {
                    this.currentRange = null;
 
                    if (this.limitsUpdatedAt >= this.nrRanges)
                        return false;
                }
            }
        }
 
        public async Task<bool> MovePreviousAsyncLocked()
        {
            int i;
 
            while (true)
            {
                if (this.currentRange is null)
                {
                    List<KeyValuePair<string, object>> SearchParameters = new List<KeyValuePair<string, object>>();
                    List<KeyValuePair<string, IApplicableFilter>> StartFilters = null;
                    List<KeyValuePair<string, IApplicableFilter>> EndFilters = null;
                    RangeInfo Range;
                    object Value;
 
                    for (i = 0; i < this.nrRanges; i++)
                    {
                        Range = this.currentLimits[i];
 
                        if (Range.IsPoint)
                        {
                            if (EndFilters is null)
                                EndFilters = new List<KeyValuePair<string, IApplicableFilter>>();
 
                            SearchParameters.Add(new KeyValuePair<string, object>(Range.FieldName, Range.Point));
                            EndFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldEqualTo(Range.FieldName, Range.Point)));
                        }
                        else
                        {
                            if (Range.HasMin)
                            {
                                Value = Range.Min;
 
                                if (this.ascending[i])
                                {
                                    if (EndFilters is null)
                                        EndFilters = new List<KeyValuePair<string, IApplicableFilter>>();
 
                                    if (Range.MinInclusive)
                                        EndFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldGreaterOrEqualTo(Range.FieldName, Value)));
                                    else
                                        EndFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldGreaterThan(Range.FieldName, Value)));
                                }
                                else
                                {
                                    if (StartFilters is null)
                                        StartFilters = new List<KeyValuePair<string, IApplicableFilter>>();
 
                                    if (Range.MinInclusive)
                                        StartFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldGreaterOrEqualTo(Range.FieldName, Value)));
                                    else
                                    {
                                        StartFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldGreaterThan(Range.FieldName, Value)));
 
                                        if (!Comparison.Increment(ref Value))
                                            return false;
                                    }
 
                                    SearchParameters.Add(new KeyValuePair<string, object>(Range.FieldName, Value));
                                }
                            }
 
                            if (Range.HasMax)
                            {
                                Value = Range.Max;
 
                                if (this.ascending[i])
                                {
                                    if (StartFilters is null)
                                        StartFilters = new List<KeyValuePair<string, IApplicableFilter>>();
 
                                    if (Range.MaxInclusive)
                                        StartFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldLesserOrEqualTo(Range.FieldName, Value)));
                                    else
                                    {
                                        StartFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldLesserThan(Range.FieldName, Value)));
 
                                        if (!Comparison.Decrement(ref Value))
                                            return false;
                                    }
 
                                    SearchParameters.Add(new KeyValuePair<string, object>(Range.FieldName, Value));
                                }
                                else
                                {
                                    if (EndFilters is null)
                                        EndFilters = new List<KeyValuePair<string, IApplicableFilter>>();
 
                                    if (Range.MaxInclusive)
                                        EndFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldLesserOrEqualTo(Range.FieldName, Value)));
                                    else
                                        EndFilters.Add(new KeyValuePair<string, IApplicableFilter>(Range.FieldName, new FilterFieldLesserThan(Range.FieldName, Value)));
                                }
                            }
                        }
                    }
 
                    if (this.firstAscending)
                        this.currentRange = await this.index.FindLastLesserOrEqualToLocked<T>(SearchParameters.ToArray());
                    else
                        this.currentRange = await this.index.FindFirstGreaterOrEqualToLocked<T>(SearchParameters.ToArray());
 
                    this.startRangeFilters = StartFilters?.ToArray();
                    this.endRangeFilters = EndFilters?.ToArray();
                    this.limitsUpdatedAt = this.nrRanges;
                }
 
                if (!await this.currentRange.MovePreviousAsyncLocked())
                {
                    this.currentRange = null;
 
                    if (this.limitsUpdatedAt >= this.nrRanges)
                        return false;
 
                    continue;
                }
 
                if (!this.currentRange.CurrentTypeCompatible)
                    continue;
 
                object CurrentValue = this.currentRange.Current;
                IObjectSerializer CurrentSerializer = this.currentRange.CurrentSerializer;
                string OutOfStartRangeField = null;
                string OutOfEndRangeField = null;
                bool Ok = true;
                bool Smaller;
 
                if (!(this.additionalfilters is null))
                {
                    foreach (IApplicableFilter Filter in this.additionalfilters)
                    {
                        if (!await Filter.AppliesTo(CurrentValue, CurrentSerializer, this.provider))
                        {
                            Ok = false;
                            break;
                        }
                    }
                }
 
                if (!(this.startRangeFilters is null))
                {
                    foreach (KeyValuePair<string, IApplicableFilter> Filter in this.startRangeFilters)
                    {
                        if (!await Filter.Value.AppliesTo(CurrentValue, CurrentSerializer, this.provider))
                        {
                            OutOfStartRangeField = Filter.Key;
                            Ok = false;
                            break;
                        }
                    }
                }
 
                if (!(this.endRangeFilters is null) && OutOfStartRangeField is null)
                {
                    foreach (KeyValuePair<string, IApplicableFilter> Filter in this.endRangeFilters)
                    {
                        if (!await Filter.Value.AppliesTo(CurrentValue, CurrentSerializer, this.provider))
                        {
                            OutOfEndRangeField = Filter.Key;
                            Ok = false;
                            break;
                        }
                    }
                }
 
                for (i = 0; i < this.limitsUpdatedAt; i++)
                {
                    object FieldValue = await CurrentSerializer.TryGetFieldValue(this.ranges[i].FieldName, CurrentValue);
 
                    if (!(FieldValue is null))
                    {
                        if (this.ascending[i])
                        {
                            if (this.currentLimits[i].SetMax(FieldValue, !(OutOfStartRangeField is null), out Smaller) && Smaller)
                            {
                                i++;
                                this.limitsUpdatedAt = i;
 
                                while (i < this.nrRanges)
                                {
                                    this.ranges[i].CopyTo(this.currentLimits[i]);
                                    i++;
                                }
                            }
                        }
                        else
                        {
                            if (this.currentLimits[i].SetMin(FieldValue, !(OutOfStartRangeField is null), out Smaller) && Smaller)
                            {
                                i++;
                                this.limitsUpdatedAt = i;
 
                                while (i < this.nrRanges)
                                {
                                    this.ranges[i].CopyTo(this.currentLimits[i]);
                                    i++;
                                }
                            }
                        }
                    }
                }
 
                if (Ok)
                    return true;
                else if (!(OutOfStartRangeField is null) || !(OutOfEndRangeField is null))
                {
                    this.currentRange = null;
 
                    if (this.limitsUpdatedAt >= this.nrRanges)
                        return false;
                }
            }
        }
 
        public bool SameSortOrder(string[] ConstantFields, string[] SortOrder)
        {
            return this.index.SameSortOrder(ConstantFields, SortOrder);
        }
 
        public bool ReverseSortOrder(string[] ConstantFields, string[] SortOrder)
        {
            return this.index.ReverseSortOrder(ConstantFields, SortOrder);
        }
 
        public Task ContinueAfterLocked(T LastItem)
        {
            throw new NotSupportedException("Paginated search is not supported for queries with multiple ranges.");
        }
 
        public Task ContinueBeforeLocked(T LastItem)
        {
            throw new NotSupportedException("Paginated search is not supported for queries with multiple ranges.");
        }
    }
}