LesserThan.cs

using System.Collections.Generic;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Operators.Comparisons
{
    public class LesserThan : BinaryScalarOperator
    {
        public LesserThan(ScriptNode Left, ScriptNode Right, int Start, int Length, Expression Expression)
            : base(Left, Right, Start, Length, Expression)
        {
        }
 
        public override IElement EvaluateScalar(IElement Left, IElement Right, Variables Variables)
        {
            if (!(Left.AssociatedSet is IOrderedSet S))
                throw new ScriptRuntimeException("Cannot compare operands.", this);
 
            if (S.Compare(Left, Right) < 0)
                return BooleanValue.True;
            else
                return BooleanValue.False;
        }
 
        public override PatternMatchResult PatternMatch(IElement CheckAgainst, Dictionary<string, IElement> AlreadyFound)
        {
            int i;
 
            if (!(CheckAgainst.AssociatedSet is IOrderedSet S))
                return PatternMatchResult.NoMatch;
 
            if (this.left is ConstantElement LeftConstant)
            {
                i = S.Compare(LeftConstant.Constant, CheckAgainst);
                if (i < 0)
                    return this.right.PatternMatch(CheckAgainst, AlreadyFound);
                else
                    return PatternMatchResult.NoMatch;
            }
 
            if (this.right is ConstantElement RightConstant)
            {
                i = S.Compare(CheckAgainst, RightConstant.Constant);
                if (i < 0)
                    return this.left.PatternMatch(CheckAgainst, AlreadyFound);
                else
                    return PatternMatchResult.NoMatch;
            }
 
            if (this.left is VariableReference LeftReference &&
                (AlreadyFound.TryGetValue(LeftReference.VariableName, out IElement Value) ||
                Expression.TryGetConstant(LeftReference.VariableName, null, out Value)))
            {
                i = S.Compare(Value, CheckAgainst);
                if (i < 0)
                    return this.right.PatternMatch(CheckAgainst, AlreadyFound);
                else
                    return PatternMatchResult.NoMatch;
            }
 
            if (this.right is VariableReference RightReference &&
                (AlreadyFound.TryGetValue(RightReference.VariableName, out Value) ||
                Expression.TryGetConstant(RightReference.VariableName, null, out Value)))
            {
                i = S.Compare(CheckAgainst, Value);
                if (i < 0)
                    return this.left.PatternMatch(CheckAgainst, AlreadyFound);
                else
                    return PatternMatchResult.NoMatch;
            }
 
            return PatternMatchResult.NoMatch;
        }
    }
}