Sequence.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
 
namespace Waher.Script.Operators
{
    public class Sequence : ScriptNode
    {
        private readonly LinkedList<ScriptNode> statements;
        private bool isAsync;
 
        public Sequence(LinkedList<ScriptNode> Statements, int Start, int Length, Expression Expression)
            : base(Start, Length, Expression)
        {
            this.statements = Statements;
            this.statements?.SetParent(this);
 
            this.CalcIsAsync();
        }
 
        private void CalcIsAsync()
        {
            this.isAsync = false;
 
            foreach (ScriptNode Statement in this.statements)
            {
                if (Statement?.IsAsynchronous ?? false)
                {
                    this.isAsync = true;
                    break;
                }
            }
        }
 
 
        public LinkedList<ScriptNode> Statements => this.statements;
 
        public override bool IsAsynchronous => this.isAsync;
 
        public override IElement Evaluate(Variables Variables)
        {
            IElement Result = null;
 
            foreach (ScriptNode Node in this.statements)
                Result = Node.Evaluate(Variables);
 
            return Result;
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            if (!this.isAsync)
                return this.Evaluate(Variables);
 
            IElement Result = null;
 
            foreach (ScriptNode Node in this.statements)
                Result = await Node.EvaluateAsync(Variables);
 
            return Result;
        }
 
        public override bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            LinkedListNode<ScriptNode> Loop;
 
            if (Order == SearchMethod.DepthFirst)
            {
                Loop = this.statements.First;
 
                while (!(Loop is null))
                {
                    if (!(Loop.Value?.ForAllChildNodes(Callback, State, Order) ?? true))
                        return false;
 
                    Loop = Loop.Next;
                }
            }
 
            Loop = this.statements.First;
            bool RecalcIsAsync = false;
 
            while (!(Loop is null))
            {
                ScriptNode Node = Loop.Value;
                if (!(Node is null))
                {
                    bool Result = Callback(Node, out ScriptNode NewNode, State);
                    if (!(NewNode is null))
                    {
                        Loop.Value = NewNode;
                        NewNode.SetParent(this);
                        Node = NewNode;
 
                        RecalcIsAsync = true;
                    }
 
                    if (!Result || (Order == SearchMethod.TreeOrder && !Node.ForAllChildNodes(Callback, State, Order)))
                    {
                        if (RecalcIsAsync)
                            this.CalcIsAsync();
 
                        return false;
                    }
                }
 
                Loop = Loop.Next;
            }
 
            if (RecalcIsAsync)
                this.CalcIsAsync();
 
            if (Order == SearchMethod.BreadthFirst)
            {
                Loop = this.statements.First;
 
                while (!(Loop is null))
                {
                    if (!(Loop.Value?.ForAllChildNodes(Callback, State, Order) ?? true))
                        return false;
 
                    Loop = Loop.Next;
                }
            }
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            return obj is Sequence O &&
                AreEqual(this.statements, O.statements) &&
                base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            int Result = base.GetHashCode();
            Result ^= Result << 5 ^ GetHashCode(this.statements);
            return Result;
        }
 
    }
}