XmlScriptDocument.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Xml.Model
{
    public class XmlScriptDocument : XmlScriptNode
    {
        private readonly XmlScriptProcessingInstruction[] processingInstructions;
        private XmlScriptElement root;
        private readonly int nrInstructions;
        private bool isAsync;
 
        public XmlScriptDocument(XmlScriptElement Root, XmlScriptProcessingInstruction[] ProcessingInstructions,
            int Start, int Length, Expression Expression)
            : base(Start, Length, Expression)
        {
            this.root = Root;
            this.root?.SetParent(this);
        
            this.processingInstructions = ProcessingInstructions;
            this.processingInstructions?.SetParent(this);
            
            this.nrInstructions = ProcessingInstructions.Length;
 
            this.CalcIsAsync();
        }
 
        private void CalcIsAsync()
        {
            this.isAsync = this.root?.IsAsynchronous ?? false;
            if (this.isAsync)
                return;
 
            for (int i = 0; i < this.nrInstructions; i++)
            {
                if (this.processingInstructions[i]?.IsAsynchronous ?? false)
                {
                    this.isAsync = true;
                    break;
                }
            }
        }
 
 
        public XmlScriptElement Root => this.root;
 
        public override bool IsAsynchronous => this.isAsync;
 
        public override bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            int i, c = this.processingInstructions.Length;
 
            if (Order == SearchMethod.DepthFirst)
            {
                for (i = 0; i < c; i++)
                {
                    if (!this.processingInstructions[i].ForAllChildNodes(Callback, State, Order))
                        return false;
                }
 
                if (!this.root.ForAllChildNodes(Callback, State, Order))
                    return false;
            }
 
            ScriptNode NewNode;
            bool RecalcIsAsync = false;
            bool b;
 
            for (i = 0; i < this.nrInstructions; i++)
            {
                b = !Callback(this.processingInstructions[i], out NewNode, State);
                if (!(NewNode is null) && NewNode is XmlScriptProcessingInstruction Instruction)
                {
                    this.processingInstructions[i] = Instruction;
                    Instruction.SetParent(this);
 
                    RecalcIsAsync = true;
                }
 
                if (b || (Order == SearchMethod.TreeOrder && !this.processingInstructions[i].ForAllChildNodes(Callback, State, Order)))
                {
                    if (RecalcIsAsync)
                        this.CalcIsAsync();
 
                    return false;
                }
            }
 
            if (!(this.root is null))
            {
                b = !Callback(this.root, out NewNode, State);
                if (!(NewNode is null) && NewNode is XmlScriptElement NewRoot)
                {
                    this.root = NewRoot;
                    this.root.SetParent(this);
 
                    RecalcIsAsync = true;
                }
 
                if (b || (Order == SearchMethod.TreeOrder && !this.root.ForAllChildNodes(Callback, State, Order)))
                {
                    if (RecalcIsAsync)
                        this.CalcIsAsync();
 
                    return false;
                }
            }
 
            if (Order == SearchMethod.BreadthFirst)
            {
                for (i = 0; i < c; i++)
                {
                    if (!this.processingInstructions[i].ForAllChildNodes(Callback, State, Order))
                        return false;
                }
 
                if (!this.root.ForAllChildNodes(Callback, State, Order))
                    return false;
            }
 
            return true;
        }
 
        public override IElement Evaluate(Variables Variables)
        {
            XmlDocument Doc = new XmlDocument()
            {
                PreserveWhitespace = true
            };
 
            this.Build(Doc, null, Variables);
 
            return new ObjectValue(Doc);
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            if (!this.isAsync)
                return this.Evaluate(Variables);
 
            XmlDocument Doc = new XmlDocument()
            {
                PreserveWhitespace = true
            };
 
            await this.BuildAsync(Doc, null, Variables);
 
            return new ObjectValue(Doc);
        }
 
        internal override void Build(XmlDocument Document, XmlElement Parent, Variables Variables)
        {
            foreach (XmlScriptProcessingInstruction PI in this.processingInstructions)
                PI.Build(Document, Parent, Variables);
 
            this.root?.Build(Document, Parent, Variables);
        }
 
        internal override async Task BuildAsync(XmlDocument Document, XmlElement Parent, Variables Variables)
        {
            foreach (XmlScriptProcessingInstruction PI in this.processingInstructions)
                await PI.BuildAsync(Document, Parent, Variables);
 
            if (!(this.root is null))
                await this.root.BuildAsync(Document, Parent, Variables);
        }
 
        public override PatternMatchResult PatternMatch(IElement CheckAgainst, Dictionary<string, IElement> AlreadyFound)
        {
            if (!(CheckAgainst?.AssociatedObjectValue is XmlNode Node))
                return PatternMatchResult.NoMatch;
 
            return this.PatternMatch(Node, AlreadyFound);
        }
 
        public override PatternMatchResult PatternMatch(XmlNode CheckAgainst, Dictionary<string, IElement> AlreadyFound)
        {
            System.Collections.IEnumerable Nodes;
 
            if (CheckAgainst is XmlDocument Doc)
                Nodes = Doc.ChildNodes;
            else if (CheckAgainst is XmlElement E)
                Nodes = new XmlElement[] { E };
            else
                return PatternMatchResult.NoMatch;
 
            int PiIndex = 0;
            bool RootMatched = false;
            PatternMatchResult Result;
 
            foreach (XmlNode N in Nodes)
            {
                if (N is XmlElement)
                {
                    if (RootMatched || this.root is null)
                        return PatternMatchResult.NoMatch;
 
                    if ((Result = this.root.PatternMatch(N, AlreadyFound)) != PatternMatchResult.Match)
                        return Result;
 
                    RootMatched = true;
                }
                else if (N is XmlDeclaration)
                {
                    if (PiIndex < this.processingInstructions.Length &&
                        (Result = this.processingInstructions[PiIndex++].PatternMatch(N, AlreadyFound)) != PatternMatchResult.Match)
                    {
                        return Result;
                    }
                }
                else if (N is XmlProcessingInstruction)
                {
                    if (PiIndex >= this.processingInstructions.Length)
                        return PatternMatchResult.NoMatch;
                    else if ((Result = this.processingInstructions[PiIndex++].PatternMatch(N, AlreadyFound)) != PatternMatchResult.Match)
                        return Result;
                }
                else if (N is XmlComment || N is XmlSignificantWhitespace || N is XmlWhitespace)
                    continue;
                else
                    return PatternMatchResult.NoMatch;
            }
 
            if (!RootMatched && !(this.root is null))
                return PatternMatchResult.NoMatch;
 
            if (PiIndex < this.processingInstructions.Length)
                return PatternMatchResult.NoMatch;
 
            return PatternMatchResult.Match;
        }
 
        public override bool IsApplicable(XmlNode CheckAgainst)
        {
            return (CheckAgainst is XmlDocument);
        }
 
    }
}