NotEqualTo.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Operators.Comparisons
{
    public class NotEqualTo : BinaryOperator 
    {
        public NotEqualTo(ScriptNode Left, ScriptNode Right, int Start, int Length, Expression Expression)
            : base(Left, Right, Start, Length, Expression)
        {
        }
 
        public override IElement Evaluate(Variables Variables)
        {
            IElement Left = this.left.Evaluate(Variables);
            IElement Right = this.right.Evaluate(Variables);
 
            if (Left.Equals(Right))
                return BooleanValue.False;
            else
                return BooleanValue.True;
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            if (!this.isAsync)
                return this.Evaluate(Variables);
 
            IElement Left = await this.left.EvaluateAsync(Variables);
            IElement Right = await this.right.EvaluateAsync(Variables);
 
            if (Left.Equals(Right))
                return BooleanValue.False;
            else
                return BooleanValue.True;
        }
 
        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;
        }
    }
}