DynamicFuctionCall.cs

using System.Threading.Tasks;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Operators
{
    public class DynamicFunctionCall : NullCheckUnaryScalarOperator
    {
        private readonly ScriptNode[] arguments;
        private readonly int nrArguments;
 
        public DynamicFunctionCall(ScriptNode Function, ScriptNode[] Arguments, bool NullCheck, int Start, int Length, Expression Expression)
            : base(Function, NullCheck, Start, Length, Expression)
        {
            this.arguments = Arguments;
            this.arguments?.SetParent(this);
 
            this.nrArguments = this.arguments.Length;
 
            this.CalcIsAsync();
        }
 
        private void CalcIsAsync()
        {
            this.isAsync = this.op?.IsAsynchronous ?? false;
 
            for (int i = 0; i < this.nrArguments; i++)
            {
                if (this.arguments[i]?.IsAsynchronous ?? false)
                {
                    this.isAsync = true;
                    break;
                }
            }
        }
 
        public ScriptNode[] Arguments => this.arguments;
 
        public override bool IsAsynchronous => this.isAsync || base.IsAsynchronous;
 
        public override IElement EvaluateScalar(IElement Operand, Variables Variables)
        {
            object Obj = Operand.AssociatedObjectValue;
            if (Obj is null && this.nullCheck)
                return ObjectValue.Null;
 
            if (!(Obj is ILambdaExpression Lambda))
                throw new ScriptRuntimeException("Expected a lambda expression.", this);
 
            if (this.nrArguments != Lambda.NrArguments)
                throw new ScriptRuntimeException("Expected " + Lambda.NrArguments.ToString() + " arguments.", this);
 
            IElement[] Arg = new IElement[this.nrArguments];
            ScriptNode Node;
            int i;
 
            for (i = 0; i < this.nrArguments; i++)
            {
                Node = this.arguments[i];
                if (Node is null)
                    Arg[i] = ObjectValue.Null;
                else
                    Arg[i] = Node.Evaluate(Variables);
            }
 
            return Lambda.Evaluate(Arg, Variables);
        }
 
        public override async Task<IElement> EvaluateScalarAsync(IElement Operand, Variables Variables)
        {
            object Obj = Operand.AssociatedObjectValue;
            if (Obj is null && this.nullCheck)
                return ObjectValue.Null;
 
            if (!(Obj is ILambdaExpression Lambda))
                throw new ScriptRuntimeException("Expected a lambda expression.", this);
 
            if (this.nrArguments != Lambda.NrArguments)
                throw new ScriptRuntimeException("Expected " + Lambda.NrArguments.ToString() + " arguments.", this);
 
            IElement[] Arg = new IElement[this.nrArguments];
            ScriptNode Node;
            int i;
 
            for (i = 0; i < this.nrArguments; i++)
            {
                Node = this.arguments[i];
                if (Node is null)
                    Arg[i] = ObjectValue.Null;
                else
                    Arg[i] = await Node.EvaluateAsync(Variables);
            }
 
            return await Lambda.EvaluateAsync(Arg, Variables);
        }
 
        public override bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            int i;
 
            if (Order == SearchMethod.DepthFirst)
            {
                if (!this.arguments.ForAllChildNodes(Callback, State, Order))
                    return false;
            }
 
            ScriptNode Node;
            bool RecalcIsAsync = false;
 
            for (i = 0; i < this.nrArguments; i++)
            {
                Node = this.arguments[i];
                if (!(Node is null))
                {
                    bool b = !Callback(Node, out ScriptNode NewNode, State);
                    if (!(NewNode is null))
                    {
                        this.arguments[i] = Node = NewNode;
                        NewNode.SetParent(this);
 
                        RecalcIsAsync = true;
                    }
 
                    if (b || (Order == SearchMethod.TreeOrder && !Node.ForAllChildNodes(Callback, State, Order)))
                    {
                        if (RecalcIsAsync)
                            this.CalcIsAsync();
 
                        return false;
                    }
                }
            }
 
            if (RecalcIsAsync)
                this.CalcIsAsync();
 
            if (Order == SearchMethod.BreadthFirst)
            {
                if (!this.arguments.ForAllChildNodes(Callback, State, Order))
                    return false;
            }
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            return obj is DynamicFunctionCall O &&
                AreEqual(this.arguments, O.arguments) &&
                base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            int Result = base.GetHashCode();
            Result ^= Result << 5 ^ GetHashCode(this.arguments);
            return Result;
        }
    }
}