XmlScriptAttributeScript.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 XmlScriptAttributeScript : XmlScriptAttribute
    {
        private ScriptNode node;
        private bool isAsync;
        private string variableReference;
 
        public XmlScriptAttributeScript(string Name, ScriptNode Node, int Start, int Length, Expression Expression)
            : base(Name, Start, Length, Expression)
        {
            this.node = Node;
            this.node?.SetParent(this);
 
            this.isAsync = Node?.IsAsynchronous ?? false;
 
            if (Node is VariableReference Ref)
                this.variableReference = Ref.VariableName;
            else
                this.variableReference = null;
        }
 
        public override bool IsAsynchronous => this.isAsync;
 
        public override bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            if (Order == SearchMethod.DepthFirst)
            {
                if (!this.node.ForAllChildNodes(Callback, State, Order))
                    return false;
            }
 
            bool b = !Callback(this.node, out ScriptNode NewNode, State);
            if (!(NewNode is null))
            {
                this.node = NewNode;
                this.node.SetParent(this);
 
                this.isAsync = NewNode.IsAsynchronous;
 
                if (NewNode is VariableReference Ref)
                    this.variableReference = Ref.VariableName;
                else
                    this.variableReference = null;
            }
 
            if (b || (Order == SearchMethod.TreeOrder && !this.node.ForAllChildNodes(Callback, State, Order)))
                return false;
 
            if (Order == SearchMethod.BreadthFirst)
            {
                if (!this.node.ForAllChildNodes(Callback, State, Order))
                    return false;
            }
 
            return true;
        }
 
        internal override void Build(XmlDocument Document, XmlElement Parent, Variables Variables)
        {
            if (string.IsNullOrEmpty(this.variableReference))
            {
                string s = EvaluateString(this.node, Variables);
                if (!(s is null))
                    Parent.SetAttribute(this.Name, s);
            }
            else
            {
                if (Variables.TryGetVariable(this.variableReference, out Variable v))
                    Parent.SetAttribute(this.Name, EvaluateString(v.ValueElement));
                else if (Expression.TryGetConstant(this.variableReference, Variables, out IElement ValueElement))
                    Parent.SetAttribute(this.Name, EvaluateString(ValueElement));
            }
        }
 
        internal override async Task BuildAsync(XmlDocument Document, XmlElement Parent, Variables Variables)
        {
            if (string.IsNullOrEmpty(this.variableReference))
            {
                string s = await EvaluateStringAsync(this.node, Variables);
                if (!(s is null))
                    Parent.SetAttribute(this.Name, s);
            }
            else
            {
                if (Variables.TryGetVariable(this.variableReference, out Variable v))
                    Parent.SetAttribute(this.Name, EvaluateString(v.ValueElement));
                else if (Expression.TryGetConstant(this.variableReference, Variables, out IElement ValueElement))
                    Parent.SetAttribute(this.Name, EvaluateString(ValueElement));
            }
        }
 
        internal override string GetValue(Variables Variables)
        {
            return EvaluateString(this.node, Variables);
        }
 
        internal override Task<string> GetValueAsync(Variables Variables)
        {
            return EvaluateStringAsync(this.node, Variables);
        }
 
        public override PatternMatchResult PatternMatch(XmlNode CheckAgainst, Dictionary<string, IElement> AlreadyFound)
        {
            if (CheckAgainst is XmlAttribute)
                return this.node.PatternMatch(new StringValue(CheckAgainst.Value), AlreadyFound);
            else if (CheckAgainst is null)
                return this.node.PatternMatch(ObjectValue.Null, AlreadyFound);
            else
                return PatternMatchResult.NoMatch;
        }
 
        public override PatternMatchResult PatternMatch(string CheckAgainst, Dictionary<string, IElement> AlreadyFound)
        {
            if (CheckAgainst is null)
                return this.node.PatternMatch(ObjectValue.Null, AlreadyFound);
            else
                return this.node.PatternMatch(new StringValue(CheckAgainst), AlreadyFound);
        }
 
        public override bool IsApplicable(string CheckAgainst)
        {
            return true;
        }
    }
}