FunctionTwoVariables.cs

using System;
using System.Threading.Tasks;
using Waher.Script.Abstraction.Elements;
 
namespace Waher.Script.Model
{
    public abstract class FunctionTwoVariables : Function
    {
        private ScriptNode argument1;
        private ScriptNode argument2;
        private bool isAsync;
 
        public FunctionTwoVariables(ScriptNode Argument1, ScriptNode Argument2, int Start, int Length, Expression Expression)
            : base(Start, Length, Expression)
        {
            this.argument1 = Argument1;
            this.argument1?.SetParent(this);
 
            this.argument2 = Argument2;
            this.argument2?.SetParent(this);
 
            this.CalcIsAsync();
        }
 
        private void CalcIsAsync()
        {
            this.isAsync =
                (this.argument1?.IsAsynchronous ?? false) ||
                (this.argument2?.IsAsynchronous ?? false);
        }
 
        public ScriptNode Argument1 => this.argument1;
 
        public ScriptNode Argument2 => this.argument2;
 
        public override string[] DefaultArgumentNames => new string[] { "x", "y" };
 
        public override bool IsAsynchronous => this.isAsync;
 
        public override IElement Evaluate(Variables Variables)
        {
            IElement Arg1 = this.argument1.Evaluate(Variables);
            IElement Arg2 = this.argument2.Evaluate(Variables);
 
            return this.Evaluate(Arg1, Arg2, Variables);
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            if (!this.IsAsynchronous)
                return this.Evaluate(Variables);
 
            IElement Arg1 = await this.argument1.EvaluateAsync(Variables);
            IElement Arg2 = await this.argument2.EvaluateAsync(Variables);
 
            return await this.EvaluateAsync(Arg1, Arg2, Variables);
        }
 
        public abstract IElement Evaluate(IElement Argument1, IElement Argument2, Variables Variables);
 
        public virtual Task<IElement> EvaluateAsync(IElement Argument1, IElement Argument2, Variables Variables)
        {
            return Task.FromResult(this.Evaluate(Argument1, Argument2, Variables));
        }
 
        public override bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            if (Order == SearchMethod.DepthFirst)
            {
                if (!(this.argument1?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
 
                if (!(this.argument2?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
            }
 
            ScriptNode NewNode;
            bool RecalcIsAsync = false;
            bool b;
 
            if (!(this.argument1 is null))
            {
                b = !Callback(this.argument1, out NewNode, State);
                if (!(NewNode is null))
                {
                    this.argument1 = NewNode;
                    this.argument1.SetParent(this);
 
                    RecalcIsAsync = true;
                }
 
                if (b || (Order == SearchMethod.TreeOrder && !this.argument1.ForAllChildNodes(Callback, State, Order)))
                {
                    if (RecalcIsAsync)
                        this.CalcIsAsync();
 
                    return false;
                }
            }
 
            if (!(this.argument2 is null))
            {
                b = !Callback(this.argument2, out NewNode, State);
                if (!(NewNode is null))
                {
                    this.argument2 = NewNode;
                    this.argument2.SetParent(this);
 
                    RecalcIsAsync = true;
                }
 
                if (b || (Order == SearchMethod.TreeOrder && !this.argument2.ForAllChildNodes(Callback, State, Order)))
                {
                    if (RecalcIsAsync)
                        this.CalcIsAsync();
 
                    return false;
                }
            }
 
            if (RecalcIsAsync)
                this.CalcIsAsync();
 
            if (Order == SearchMethod.BreadthFirst)
            {
                if (!(this.argument1?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
 
                if (!(this.argument2?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
            }
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            return obj is FunctionTwoVariables O &&
                this.argument1.Equals(O.argument1) &&
                this.argument2.Equals(O.argument2) &&
                base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            int Result = base.GetHashCode();
            Result ^= Result << 5 ^ this.argument1.GetHashCode();
            Result ^= Result << 5 ^ this.argument2.GetHashCode();
            return Result;
        }
 
    }
}