StateMachineNode.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Persistence.Attributes;
using Waher.Service.IoTBroker.NeuroFeatures;
using Waher.Service.IoTBroker.StateMachines.Model.Values;
 
namespace Waher.Service.IoTBroker.StateMachines.Model
{
    public delegate bool ForEachCallback(IStateMachineNode Node, object State);
 
    [TypeName(TypeNameSerialization.FullName)]
    public abstract class StateMachineNode : IStateMachineNode
    {
        private IStateMachineNode[] childNodes;
        private StateMachine stateMachine;
 
        public StateMachineNode()
        {
        }
 
        public abstract string LocalName { get; }
 
        public virtual string Namespace => StateMachineProcessor.StateMachineNamespace;
 
        public StateMachine StateMachine => this.stateMachine;
 
        [DefaultValueNull]
        public IStateMachineNode[] ChildNodes
        {
            get => this.childNodes;
            set
            {
                this.childNodes = value;
                this.OnChildNodesUpdated();
            }
        }
 
        protected virtual void OnChildNodesUpdated()
        {
            // Do nothing by default.
        }
 
        public abstract IStateMachineNode Create();
 
        public virtual Task Parse(XmlElement Xml)
        {
            List<IStateMachineNode> Children = null;
 
            foreach (XmlNode N in Xml.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    if (Children is null)
                        Children = new List<IStateMachineNode>();
 
                    Children.Add(StateMachineProcessor.Create(E));
                }
            }
 
            this.ChildNodes = Children?.ToArray();
 
            return Task.CompletedTask;
        }
 
        protected T GetChildElement<T>(bool Required)
            where T : StateMachineNode
        {
            T Result = this.GetChildElement<T>();
            if (!(Result is null))
                return Result;
 
            if (Required)
                throw new Exception("Expected element: " + typeof(T).FullName);
 
            return default;
        }
 
        protected T GetChildElement<T>()
            where T : IStateMachineNode
        {
            if (this.ChildNodes is null)
                return default;
 
            foreach (IStateMachineNode Node in this.ChildNodes)
            {
                if (Node is T Item)
                    return Item;
            }
 
            return default;
        }
 
        protected T[] GetChildElements<T>()
            where T : IStateMachineNode
        {
            if (this.ChildNodes is null)
                return new T[0];
 
            List<T> Result = null;
 
            foreach (IStateMachineNode Node in this.ChildNodes)
            {
                if (Node is T Item)
                {
                    if (Result is null)
                        Result = new List<T>();
 
                    Result.Add(Item);
                }
            }
 
            return Result?.ToArray() ?? new T[0];
        }
 
        protected void ConvertValueAttributeToElement<ValueType>(XmlElement Xml, bool Required)
            where ValueType : Value
        {
            this.ConvertValueAttributesToElements(Xml, new Type[] { typeof(ValueType) }, new bool[] { Required });
        }
 
        protected void ConvertValueAttributesToElements(XmlElement Xml, Type[] ValueTypes, bool[] Required)
        {
            Dictionary<Type, bool> Types = new Dictionary<Type, bool>();
            int i, c = ValueTypes.Length;
 
            if (c != Required.Length)
                throw new ArgumentException("Array lengths must match.", nameof(Required));
 
            for (i = 0; i < c; i++)
                Types[ValueTypes[i]] = Required[i];
 
            if (!(this.ChildNodes is null))
            {
                foreach (IStateMachineNode Node in this.ChildNodes)
                    Types.Remove(Node.GetType());
            }
 
            List<IStateMachineNode> ToAdd = null;
 
            foreach (KeyValuePair<Type, bool> P in Types)
            {
                Value Result = (Value)Activator.CreateInstance(P.Key);
                string s = Result.LocalName;
 
                if (!string.IsNullOrEmpty(s))
                {
                    s = s.Substring(0, 1).ToLower() + s.Substring(1);
                    if (Xml.HasAttribute(s))
                    {
                        if (ToAdd is null)
                            ToAdd = new List<IStateMachineNode>();
 
                        Result.Node = Value.ParseAttributeValue(Xml.GetAttribute(s));
                        ToAdd.Add(Result);
                    }
                    else if (P.Value)
                        throw new Exception("Required child element (or corresponding attribute) missing: " + Result.LocalName);
                }
            }
 
            if (!(ToAdd is null))
            {
                if (this.childNodes is null)
                    this.childNodes = ToAdd.ToArray();
                else
                {
                    c = this.childNodes.Length;
                    i = c + ToAdd.Count;
 
                    Array.Resize(ref this.childNodes, i);
                    ToAdd.CopyTo(this.childNodes, c);
                }
 
                this.OnChildNodesUpdated();
            }
        }
 
        protected T GetValueElement<T>()
            where T : Value
        {
            if (!(this.ChildNodes is null))
            {
                foreach (IStateMachineNode Node in this.ChildNodes)
                {
                    if (Node is T Element)
                        return Element;
                }
            }
 
            return null;
        }
 
        public bool ForEach(ForEachCallback Callback, object State)
        {
            if (!Callback(this, State))
                return false;
 
            if (!(this.ChildNodes is null))
            {
                foreach (IStateMachineNode Node in this.ChildNodes)
                {
                    if (!Node.ForEach(Callback, State))
                        return false;
                }
            }
 
            return true;
        }
 
        public virtual void IndexElement(StateMachine Machine)
        {
            this.stateMachine = Machine;
        }
 
        public virtual void CheckReferences(StateMachine Machine, Token Token)
        {
            // Do nothing by default.
        }
 
    }
}