QuaternaryOperator.cs

using System;
 
namespace Waher.Script.Model
{
    public abstract class QuaternaryOperator : TernaryOperator
    {
        protected ScriptNode middle2;
 
        public QuaternaryOperator(ScriptNode Left, ScriptNode Middle1, ScriptNode Middle2, ScriptNode Right, int Start, int Length, Expression Expression)
            : base(Left, Middle1, Right, Start, Length, Expression)
        {
            this.middle2 = Middle2;
            this.middle2?.SetParent(this);
 
            this.CalcIsAsync();
        }
 
        protected override void CalcIsAsync()
        {
            this.isAsync =
                (this.left?.IsAsynchronous ?? false) ||
                (this.middle?.IsAsynchronous ?? false) ||
                (this.middle2?.IsAsynchronous ?? false) ||
                (this.right?.IsAsynchronous ?? false);
        }
 
        public ScriptNode Middle2Operand => this.middle2;
 
        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.middle?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
 
                if (!(this.middle2?.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.middle is null))
            {
                b = !Callback(this.middle, out NewNode, State);
                if (!(NewNode is null))
                {
                    this.middle = NewNode;
                    this.middle.SetParent(this);
                
                    RecalcIsAsync = true;
                }
 
                if (b || (Order == SearchMethod.TreeOrder && !this.middle.ForAllChildNodes(Callback, State, Order)))
                {
                    if (RecalcIsAsync)
                        this.CalcIsAsync();
 
                    return false;
                }
            }
 
            if (!(this.middle2 is null))
            {
                b = !Callback(this.middle2, out NewNode, State);
                if (!(NewNode is null))
                {
                    this.middle2 = NewNode;
                    this.middle2.SetParent(this);
                
                    RecalcIsAsync = true;
                }
 
                if (b || (Order == SearchMethod.TreeOrder && !this.middle2.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.middle?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
 
                if (!(this.middle2?.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 QuaternaryOperator O &&
                AreEqual(this.middle2, O.middle2) &&
                base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            int Result = base.GetHashCode();
            Result ^= Result << 5 ^ GetHashCode(this.middle2);
            return Result;
        }
 
    }
}