Like.cs

using System.Collections.Generic;
using System.Text.RegularExpressions;
using Waher.Runtime.Collections;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Operators.Comparisons
{
    public delegate string ExpressionTransform(string Expression);
 
    public class Like : BinaryScalarOperator
    {
        public Like(ScriptNode Left, ScriptNode Right, int Start, int Length, Expression Expression)
            : base(Left, Right, Start, Length, Expression)
        {
        }
 
        public event ExpressionTransform TransformExpression;
 
        public override IElement EvaluateScalar(IElement Left, IElement Right, Variables Variables)
        {
            if (!(Left.AssociatedObjectValue is string sl))
                throw new ScriptRuntimeException("String values expected.", this);
 
            if (!(Right.AssociatedObjectValue is string sr))
                throw new ScriptRuntimeException("String values expected.", this);
 
            Match M;
 
            ExpressionTransform h = this.TransformExpression;
            if (!(h is null))
                sr = h(sr);
 
            M = this.Matches(sl, sr, out string[] GroupNames);
 
            if (M.Success)
            {
                if (!(GroupNames is null))
                {
                    foreach (string GroupName in GroupNames)
                    {
                        Group G = M.Groups[GroupName];
                        if (G.Success)
                        {
                            string Value = G.Value;
 
                            if (Expression.TryParse(Value, out double d))
                                Variables[GroupName] = d;
                            else
                                Variables[GroupName] = Value;
 
                            Variables[GroupName + "_STR"] = Value;
                            Variables[GroupName + "_POS"] = G.Index;
                            Variables[GroupName + "_LEN"] = G.Length;
                        }
                    }
                }
 
                if (this.partialMatch || (M.Index == 0 && M.Length == sl.Length))
                    return BooleanValue.True;
            }
 
            return BooleanValue.False;
        }
 
        protected Match Matches(string Value, string Expression, out string[] GroupNames)
        {
            lock (this.synchObject)
            {
                if (this.lastExpression is null || Expression != this.lastExpression)
                {
                    this.regex = new Regex(Expression, this.options);
                    this.lastExpression = Expression;
 
                    ChunkedList<string> Names = null;
 
                    foreach (string s in this.regex.GetGroupNames())
                    {
                        if (!int.TryParse(s, out int _))
                        {
                            if (Names is null)
                                Names = new ChunkedList<string>();
 
                            Names.Add(s);
                        }
                    }
 
                    if (Names is null)
                        this.groupNames = null;
                    else
                        this.groupNames = Names.ToArray();
                }
 
                GroupNames = this.groupNames;
 
                return this.regex.Match(Value);
            }
        }
 
        private Regex regex = null;
        private string[] groupNames = null;
        private string lastExpression = null;
        private RegexOptions options = RegexOptions.Singleline;
        private bool partialMatch = false;
        private readonly object synchObject = new object();
 
        public RegexOptions Options
        {
            get => this.options;
            set
            {
                lock (this.synchObject)
                {
                    this.options = value;
                    this.lastExpression = null;
                }
            }
        }
 
        public bool PartialMatch
        {
            get => this.partialMatch;
            set => this.partialMatch = value;
        }
 
        public override PatternMatchResult PatternMatch(IElement CheckAgainst, Dictionary<string, IElement> AlreadyFound)
        {
            if (!(CheckAgainst.AssociatedObjectValue is string sl))
                return PatternMatchResult.NoMatch;
 
            if (this.right is ConstantElement RightConstant &&
                RightConstant.Constant.AssociatedObjectValue is string sr)
            {
                ExpressionTransform h = this.TransformExpression;
                if (!(h is null))
                    sr = h(sr);
 
                Match M = this.Matches(sl, sr, out string[] GroupNames);
 
                if (M.Success)
                {
                    if (!(GroupNames is null))
                    {
                        foreach (string GroupName in GroupNames)
                        {
                            Group G = M.Groups[GroupName];
                            if (G.Success)
                            {
                                string Value = G.Value;
                                object ObjValue;
 
                                if (Expression.TryParse(Value, out double d))
                                    ObjValue = d;
                                else
                                    ObjValue = Value;
 
                                if (AlreadyFound.TryGetValue(GroupName, out IElement E) &&
                                    !E.AssociatedObjectValue.Equals(ObjValue))
                                {
                                    return PatternMatchResult.NoMatch;
                                }
 
                                AlreadyFound[GroupName] = Expression.Encapsulate(ObjValue);
                            }
                        }
                    }
 
                    return this.left.PatternMatch(CheckAgainst, AlreadyFound);
                }
            }
 
            return PatternMatchResult.NoMatch;
        }
 
    }
}