SimulationNodeChildren.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using System.Xml;
 
namespace TAG.Simulator.ObjectModel
{
    public abstract class SimulationNodeChildren : SimulationNode, ISimulationNodeChildren
    {
        private ISimulationNode[] children;
 
        public SimulationNodeChildren(ISimulationNode Parent, Model Model)
            : base(Parent, Model)
        {
        }
 
        public ISimulationNode[] Children => this.children;
 
        public override async Task FromXml(XmlElement Definition)
        {
            if (this.ParseChildren)
            {
                List<ISimulationNode> Children = new List<ISimulationNode>();
 
                if (!(this.children is null))
                    Children.AddRange(this.children);
 
                foreach (XmlNode N in Definition.ChildNodes)
                {
                    if (N is XmlElement E)
                        Children.Add(await Factory.Create(E, this, this.Model ?? this as Model));
                }
 
                this.children = Children.ToArray();
            }
            else
                this.children = new ISimulationNode[0];
        }
 
        protected void AddChild(ISimulationNode Child)
        {
            if (this.children is null)
                this.children = new ISimulationNode[] { Child };
            else
            {
                int c = this.children.Length;
                Array.Resize<ISimulationNode>(ref this.children, c + 1);
                this.children[c] = Child;
            }
        }
 
        public virtual bool ParseChildren => true;
 
        public override async Task ForEach(ForEachCallbackMethod Method, bool DepthFirst)
        {
            if (!DepthFirst)
                await Method(this);
 
            if (!(this.children is null))
            {
                foreach (ISimulationNode Child in this.children)
                    await Child.ForEach(Method, DepthFirst);
            }
 
            if (DepthFirst)
                await Method(this);
        }
 
        public override async Task ExportMarkdown(StreamWriter Output)
        {
            if (!(this.children is null))
            {
                foreach (ISimulationNode Child in this.children)
                    await Child.ExportMarkdown(Output);
            }
        }
 
        public override async Task ExportXml(XmlWriter Output)
        {
            if (!(this.children is null))
            {
                foreach (ISimulationNode Child in this.children)
                    await Child.ExportXml(Output);
            }
        }
    }
}