UnaryOperator.cs

using System.Threading.Tasks;
using Waher.Script.Abstraction.Elements;
 
namespace Waher.Script.Model
{
    public abstract class UnaryOperator : ScriptNode
    {
        protected ScriptNode op;
 
        protected bool isAsync;
 
        public UnaryOperator(ScriptNode Operand, int Start, int Length, Expression Expression)
            : base(Start, Length, Expression)
        {
            this.op = Operand;
            this.op?.SetParent(this);
 
            this.isAsync = Operand?.IsAsynchronous ?? false;
        }
 
        public ScriptNode Operand => this.op;
 
        public virtual string DefaultVariableName
        {
            get
            {
                if (this.op is IDifferentiable Differentiable)
                    return Differentiable.DefaultVariableName;
                else
                    return null;
            }
        }
 
        public override bool IsAsynchronous => this.isAsync;
 
        public override IElement Evaluate(Variables Variables)
        {
            IElement Operand = this.op.Evaluate(Variables);
 
            return this.Evaluate(Operand, Variables);
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            if (!this.isAsync)
                return this.Evaluate(Variables);
 
            IElement Operand = await this.op.EvaluateAsync(Variables);
            return await this.EvaluateAsync(Operand, Variables);
        }
 
        public abstract IElement Evaluate(IElement Operand, Variables Variables);
 
        public virtual Task<IElement> EvaluateAsync(IElement Operand, Variables Variables)
        {
            return Task.FromResult<IElement>(this.Evaluate(Operand, Variables));
        }
 
        public override bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            if (Order == SearchMethod.DepthFirst)
            {
                if (!(this.op?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
            }
 
            if (!(this.op is null))
            {
                bool b = !Callback(this.op, out ScriptNode NewNode, State);
                if (!(NewNode is null))
                {
                    this.op = NewNode;
                    this.op.SetParent(this);
                
                    this.isAsync = NewNode.IsAsynchronous;
                }
 
                if (b || (Order == SearchMethod.TreeOrder && !this.op.ForAllChildNodes(Callback, State, Order)))
                    return false;
            }
 
            if (Order == SearchMethod.BreadthFirst)
            {
                if (!(this.op?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
            }
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            return obj is UnaryOperator O &&
                this.op.Equals(O.op) &&
                base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            int Result = base.GetHashCode();
            Result ^= Result << 5 ^ this.op.GetHashCode();
            return Result;
        }
 
    }
}