RangeInfo.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using Waher.Persistence.Filters;
 
namespace Waher.Persistence.Files.Searching
{
    public class RangeInfo : IEnumerable<Filter>
    {
        private readonly string fieldName;
        private LinkedList<Filter> filters = null;
        private object min;
        private object max;
        private object point;
        private bool minInclusive;
        private bool maxInclusive;
        private bool isRange;
        private bool isPoint;
 
        public RangeInfo(string FieldName)
        {
            this.fieldName = FieldName;
            this.filters = new LinkedList<Filter>();
        }
 
        public RangeInfo(string FieldName, LinkedList<Filter> Filters)
        {
            this.fieldName = FieldName;
            this.filters = Filters;
        }
 
        public string FieldName => this.fieldName;
 
        public object Min => this.min;
 
        public object Max => this.max;
 
        public object Point => this.point;
 
        public bool MinInclusive => this.minInclusive;
 
        public bool MaxInclusive => this.maxInclusive;
 
        public bool IsRange => this.isRange;
 
        public bool IsPoint => this.isPoint;
 
        public bool IsOpenEndedRange
        {
            get { return this.IsRange && (this.min is null || this.max is null); }
        }
 
        public bool HasMin
        {
            get { return (this.isRange && !(this.min is null)) || (this.isPoint && !(this.point is null)); }
        }
 
        public bool HasMax
        {
            get { return (this.isRange && !(this.max is null)) || (this.isPoint && !(this.point is null)); }
        }
 
        public bool HasFilters => !(this.filters is null);
 
        public void AddFilterReference(Filter Filter)
        {
            if (this.filters is null)
                this.filters = new LinkedList<Filter>();
 
            this.filters.AddLast(Filter);
        }
 
        public bool SetPoint(object Value)
        {
            int? i;
 
            if (this.isRange)
            {
                if (!(this.min is null))
                {
                    i = Comparison.Compare(this.min, Value);
 
                    if (!i.HasValue || i.Value > 0 || (i.Value == 0 && !this.minInclusive))
                        return false;
 
                    this.min = null;
                }
 
                if (!(this.max is null))
                {
                    i = Comparison.Compare(this.max, Value);
 
                    if (!i.HasValue || i.Value < 0 || (i.Value == 0 && !this.maxInclusive))
                        return false;
 
                    this.max = null;
                }
 
                this.point = Value;
                this.isRange = false;
                this.isPoint = true;
                return true;
            }
            else if (this.isPoint)
            {
                i = Comparison.Compare(this.point, Value);
                return (i.HasValue && i.Value == 0);
            }
            else
            {
                this.isPoint = true;
                this.point = Value;
                return true;
            }
        }
 
        public bool SetMin(object Value, bool Inclusive, out bool Smaller)
        {
            int? i;
 
            Smaller = false;
 
            if (this.isRange)
            {
                if (!(this.min is null))
                {
                    i = Comparison.Compare(this.min, Value);
 
                    if (!i.HasValue)
                        return false;
 
                    if (i.Value < 0)
                    {
                        Smaller = true;
 
                        if (!this.minInclusive && Inclusive)
                        {
                            if (Comparison.Increment(ref this.min))
                            {
                                i = Comparison.Compare(this.min, Value);
                                if (i.HasValue && i.Value == 0)
                                    Smaller = false;
                            }
                        }
 
                        this.min = Value;
                        this.minInclusive = Inclusive;
                    }
                    else if (i.Value == 0)
                    {
                        if (!Inclusive && this.minInclusive)
                        {
                            this.minInclusive = false;
                            Smaller = true;
                        }
                    }
                }
                else
                {
                    this.min = Value;
                    this.minInclusive = Inclusive;
                    Smaller = true;
                }
 
                if (!(this.max is null))
                {
                    i = Comparison.Compare(this.max, this.min);
                    if (!i.HasValue || i.Value < 0)
                        return false;
                    else if (i.Value == 0)
                    {
                        if (!(this.minInclusive && this.maxInclusive))
                            return false;
 
                        this.point = Value;
                        this.isPoint = true;
                        this.isRange = false;
                        this.min = null;
                        this.max = null;
                    }
                }
 
                return true;
            }
            else if (this.isPoint)
            {
                i = Comparison.Compare(this.point, Value);
 
                if (Inclusive)
                    return i.HasValue && i.Value >= 0;
                else
                    return i.HasValue && i.Value > 0;
            }
            else
            {
                this.min = Value;
                this.minInclusive = Inclusive;
                this.isRange = true;
                Smaller = true;
                return true;
            }
        }
 
        public bool SetMax(object Value, bool Inclusive, out bool Smaller)
        {
            int? i;
 
            Smaller = false;
 
            if (this.isRange)
            {
                if (!(this.max is null))
                {
                    i = Comparison.Compare(this.max, Value);
 
                    if (!i.HasValue)
                        return false;
 
                    if (i.Value > 0)
                    {
                        Smaller = true;
 
                        if (!this.maxInclusive && Inclusive)
                        {
                            if (Comparison.Decrement(ref this.max))
                            {
                                i = Comparison.Compare(this.max, Value);
                                if (i.HasValue && i.Value == 0)
                                    Smaller = false;
                            }
                        }
 
                        this.max = Value;
                        this.maxInclusive = Inclusive;
                    }
                    else if (i.Value == 0)
                    {
                        if (!Inclusive && this.maxInclusive)
                        {
                            this.maxInclusive = false;
                            Smaller = true;
                        }
                    }
                }
                else
                {
                    this.max = Value;
                    this.maxInclusive = Inclusive;
                    Smaller = true;
                }
 
                if (!(this.min is null))
                {
                    i = Comparison.Compare(this.max, this.min);
                    if (!i.HasValue || i.Value < 0)
                        return false;
                    else if (i.Value == 0)
                    {
                        if (!(this.minInclusive && this.maxInclusive))
                            return false;
 
                        this.point = Value;
                        this.isPoint = true;
                        this.isRange = false;
                        this.min = null;
                        this.max = null;
                    }
                }
 
                return true;
            }
            else if (this.isPoint)
            {
                i = Comparison.Compare(this.point, Value);
 
                return !(!i.HasValue || i.Value > 0 || (i.Value == 0 && !Inclusive));
            }
            else
            {
                this.max = Value;
                this.maxInclusive = Inclusive;
                this.isRange = true;
                Smaller = true;
                return true;
            }
        }
 
        public RangeInfo Copy()
        {
            RangeInfo Result = new RangeInfo(this.fieldName, this.filters);
            this.CopyTo(Result);
            return Result;
        }
 
        public void CopyTo(RangeInfo Destination)
        { 
            Destination.min = this.min;
            Destination.max = this.max;
            Destination.point = this.point;
            Destination.minInclusive = this.minInclusive;
            Destination.maxInclusive = this.maxInclusive;
            Destination.isRange = this.isRange;
            Destination.isPoint = this.isPoint;
        }
 
        public IEnumerator<Filter> GetEnumerator()
        {
            if (this.filters is null)
                return (IEnumerator<Filter>)Array.Empty<Filter>().GetEnumerator();
            else
                return this.filters.GetEnumerator();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }
 
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
 
            if (this.isPoint)
            {
                sb.Append(this.fieldName);
                sb.Append('=');
                sb.Append(this.point?.ToString());
            }
            else if (this.isRange)
            {
                sb.Append(this.min?.ToString());
 
                if (this.minInclusive)
                    sb.Append('≤');
                else
                    sb.Append('<');
 
                sb.Append(this.fieldName);
 
                if (this.maxInclusive)
                    sb.Append('≤');
                else
                    sb.Append('<');
 
                sb.Append(this.max?.ToString());
            }
            else
                sb.Append(this.fieldName);
 
            return sb.ToString();
        }
    }
}