BinaryOperator.cs

using System;
using System.Collections.Generic;
using Waher.Runtime.Inventory;
using Waher.Script.Abstraction.CustomOperators;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Operators.Membership;
 
namespace Waher.Script.Model
{
    public abstract class BinaryOperator : ScriptNode
    {
        protected ScriptNode left;
 
        protected ScriptNode right;
 
        protected bool isAsync;
 
        public BinaryOperator(ScriptNode Left, ScriptNode Right, int Start, int Length, Expression Expression)
            : base(Start, Length, Expression)
        {
            this.left = Left;
            this.left?.SetParent(this);
 
            this.right = Right;
            this.right?.SetParent(this);
 
            this.CalcIsAsync();
        }
 
        protected virtual void CalcIsAsync()
        {
            this.isAsync =
                (this.left?.IsAsynchronous ?? false) ||
                (this.right?.IsAsynchronous ?? false);
        }
 
        public ScriptNode LeftOperand => this.left;
 
        public ScriptNode RightOperand => this.right;
 
        public virtual string DefaultVariableName
        {
            get
            {
                if (this.left is IDifferentiable Left &&
                    this.right is IDifferentiable Right)
                {
                    string s = Left.DefaultVariableName;
                    if (s is null)
                        return null;
                    else if (s == Right.DefaultVariableName)
                        return s;
                    else
                        return null;
                }
                else
                    return null;
            }
        }
 
        public override bool IsAsynchronous => this.isAsync;
 
        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;
            }
 
            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 (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;
            }
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            return obj is BinaryOperator O &&
                AreEqual(this.left, O.left) &&
                AreEqual(this.right, O.right) &&
                base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            int Result = base.GetHashCode();
            Result ^= Result << 5 ^ GetHashCode(this.left);
            Result ^= Result << 5 ^ GetHashCode(this.right);
            return Result;
        }
 
        public static IElement EvaluateNamedOperator(string Name, IElement Left, IElement Right, ScriptNode Node)
        {
            Type LeftType = Left.AssociatedObjectValue?.GetType() ?? typeof(object);
            Type RightType = Right.AssociatedObjectValue?.GetType() ?? typeof(object);
            IBinaryOperator CustomOperator = null;
            bool Found;
 
            lock (customBinaryOperators)
            {
                Found =
                    customBinaryOperators.TryGetValue(Name, out Dictionary<Type, Dictionary<Type, IBinaryOperator>> ByLeftType) &&
                    ByLeftType.TryGetValue(LeftType, out Dictionary<Type, IBinaryOperator> ByRightType) &&
                    ByRightType.TryGetValue(RightType, out CustomOperator);
            }
 
            if (!(CustomOperator is null))
                return CustomOperator.Evaluate(new BinaryOperation(Name, Left, Right), Node);
 
            ScriptNode[] ArgumentNodes = new ScriptNode[2];
            NamedMethodCall OperatorMethod = new NamedMethodCall(null, Name, ArgumentNodes,
                false, Node?.Start ?? 0, Node?.Length ?? 0, Node?.Expression);
 
            IElement[] Arguments = new IElement[] { Left, Right };
            IElement Result = OperatorMethod.EvaluateAsync(LeftType, null, Arguments, null).Result;
 
            if (!(Result is null))
                return Result;
 
            Result = OperatorMethod.EvaluateAsync(RightType, null, Arguments, null).Result;
 
            if (!(Result is null))
                return Result;
 
            if (!Found)
            {
                BinaryOperation BinaryOperation = new BinaryOperation(Name, Left, Right);
 
                CustomOperator = Types.FindBest<IBinaryOperator, IBinaryOperation>(BinaryOperation);
 
                lock (customBinaryOperators)
                {
                    if (!customBinaryOperators.TryGetValue(Name, out Dictionary<Type, Dictionary<Type, IBinaryOperator>> ByLeftType))
                    {
                        ByLeftType = new Dictionary<Type, Dictionary<Type, IBinaryOperator>>();
                        customBinaryOperators[Name] = ByLeftType;
                    }
 
                    if (!ByLeftType.TryGetValue(LeftType, out Dictionary<Type, IBinaryOperator> ByRightType))
                    {
                        ByRightType = new Dictionary<Type, IBinaryOperator>();
                        ByLeftType[LeftType] = ByRightType;
                    }
 
                    ByRightType[RightType] = CustomOperator;
                }
 
                if (!(CustomOperator is null))
                    return CustomOperator.Evaluate(BinaryOperation, Node);
            }
 
            return null;
        }
 
        private static readonly Dictionary<string, Dictionary<Type, Dictionary<Type, IBinaryOperator>>> 
            customBinaryOperators = new Dictionary<string, Dictionary<Type, Dictionary<Type, IBinaryOperator>>>();
    }
}