LikeWithOptions.cs

using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Waher.Content.Semantic;
using Waher.Content.Semantic.Model.Literals;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Functions.Strings;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Operators.Comparisons;
 
namespace Waher.Script.Persistence.SPARQL.Filters
{
    public class LikeWithOptions : Like, IFilterNode
    {
        private ScriptNode options;
 
        public LikeWithOptions(ScriptNode Argument1, ScriptNode Argument2, ScriptNode Argument3,
            int Start, int Length, Expression Expression)
            : base(Argument1, Argument2, Start, Length, Expression)
        {
            this.options = Argument3;
            this.PartialMatch = true;
 
            this.CalcIsAsync();
        }
 
        protected override void CalcIsAsync()
        {
            base.CalcIsAsync();
 
            if (this.options?.IsAsynchronous ?? false)
                this.isAsync = true;
        }
 
        public override IElement Evaluate(Variables Variables)
        {
            if (!(this.options is null))
                this.SetOptions(this.options.Evaluate(Variables));
 
            IElement Left = this.left.Evaluate(Variables);
            IElement Right = this.right.Evaluate(Variables);
 
            return this.EvaluateScalar(Left, Right, Variables);
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            if (!(this.options is null))
                this.SetOptions(await this.options.EvaluateAsync(Variables));
 
            IElement Left = await this.left.EvaluateAsync(Variables);
            IElement Right = await this.right.EvaluateAsync(Variables);
 
            return await this.EvaluateScalarAsync(Left, Right, Variables);
        }
 
        public Task<IElement> EvaluateAsync(Variables Variables, ISemanticCube Cube, 
            SparqlQuery Query, Possibility Possibility)
        {
            return this.EvaluateAsync(Variables);
        }
 
        public ScriptNode ScriptNode => this;
 
        private void SetOptions(IElement Options)
        {
            if (!(Options.AssociatedObjectValue is string s))
                throw new ScriptRuntimeException("Options argument to regex function must be a string.", this);
 
            this.Options = Replace.GetOptions(s, this);
        }
 
        public override bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            if (Order == SearchMethod.DepthFirst)
            {
                if (!(this.left?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
 
                if (!(this.right?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
 
                if (!(this.options?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
            }
 
            ScriptNode NewNode;
            bool RecalcIsAsync = false;
            bool b;
 
            if (!(this.left is null))
            {
                b = !Callback(this.left, out NewNode, State);
                if (!(NewNode is null))
                {
                    this.left = NewNode;
                    this.left.SetParent(this);
 
                    RecalcIsAsync = true;
                }
 
                if (b || Order == SearchMethod.TreeOrder && !this.left.ForAllChildNodes(Callback, State, Order))
                {
                    if (RecalcIsAsync)
                        this.CalcIsAsync();
 
                    return false;
                }
            }
 
            if (!(this.right is null))
            {
                b = !Callback(this.right, out NewNode, State);
                if (!(NewNode is null))
                {
                    this.right = NewNode;
                    this.right.SetParent(this);
 
                    RecalcIsAsync = true;
                }
 
                if (b || Order == SearchMethod.TreeOrder && !this.right.ForAllChildNodes(Callback, State, Order))
                {
                    if (RecalcIsAsync)
                        this.CalcIsAsync();
 
                    return false;
                }
            }
 
            if (!(this.options is null))
            {
                b = !Callback(this.options, out NewNode, State);
                if (!(NewNode is null))
                {
                    this.options = NewNode;
                    this.options.SetParent(this);
 
                    RecalcIsAsync = true;
                }
 
                if (b || Order == SearchMethod.TreeOrder && !this.options.ForAllChildNodes(Callback, State, Order))
                {
                    if (RecalcIsAsync)
                        this.CalcIsAsync();
 
                    return false;
                }
            }
 
            if (RecalcIsAsync)
                this.CalcIsAsync();
 
            if (Order == SearchMethod.BreadthFirst)
            {
                if (!(this.left?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
 
                if (!(this.right?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
 
                if (!(this.options?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
            }
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            return obj is LikeWithOptions O &&
                AreEqual(this.left, O.left) &&
                AreEqual(this.right, O.right) &&
                AreEqual(this.options, O.options) &&
                base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            int Result = base.GetHashCode();
            Result ^= Result << 5 ^ GetHashCode(this.left);
            Result ^= Result << 5 ^ GetHashCode(this.right);
            Result ^= Result << 5 ^ GetHashCode(this.options);
            return Result;
        }
    }
}