SimulationNode.cs

using System;
using System.IO;
using System.Threading.Tasks;
using System.Xml;
using TAG.Simulator.ObjectModel.Actors;
using Waher.Script;
 
namespace TAG.Simulator.ObjectModel
{
    public abstract class SimulationNode : ISimulationNode
    {
        private readonly ISimulationNode parent;
        private readonly Model model;
 
        public SimulationNode(ISimulationNode Parent, Model Model)
        {
            this.parent = Parent;
            this.model = Model;
        }
 
        public ISimulationNode Parent => this.parent;
 
        public Model Model
        {
            get => this.model;
        }
 
        public virtual string Namespace => Model.ComSimNamespace;
 
        public virtual string SchemaResource => "TAG.Simulator.Schema.ComSim.xsd";
 
        public abstract string LocalName
        {
            get;
        }
 
        public abstract ISimulationNode Create(ISimulationNode Parent, Model Model);
 
        public abstract Task FromXml(XmlElement Definition);
 
        public virtual Task ForEach(ForEachCallbackMethod Method, bool DepthFirst)
        {
            return Method(this);
        }
 
        public virtual Task Initialize()
        {
            return Task.CompletedTask;
        }
 
        public virtual Task Start()
        {
            return Task.CompletedTask;
        }
 
        public virtual Task Finalize()
        {
            return Task.CompletedTask;
        }
 
        public virtual Task ExportMarkdown(StreamWriter Output)
        {
            return Task.CompletedTask;
        }
 
        public virtual Task ExportXml(XmlWriter Output)
        {
            return Task.CompletedTask;
        }
 
        protected static void Indent(StreamWriter Output, int Indentation)
        {
            if (Indentation > 0)
                Output.Write(new string('\t', Indentation));
        }
 
        public async Task<object> GetActorObjectAsync(StringAttribute Actor, Variables Variables)
        {
            string ActorStr = await Actor.GetValueAsync(Variables);
            object Result;
 
            if (Variables.TryGetVariable(ActorStr, out Variable v))
                Result = v.ValueObject;
            else
            {
                Expression Exp;
 
                lock (this.synchObj)
                {
                    if (this.lastActorExpression is null || ActorStr != this.lastActor)
                    {
                        this.lastActorExpression = new Expression(ActorStr);
                        this.lastActor = ActorStr;
                    }
 
                    Exp = this.lastActorExpression;
                }
 
                Result = await Exp.EvaluateAsync(Variables);
            }
 
            if (Result is Actor Actor2)
                return Actor2.ActivityObject;
            else
                return Result;
        }
 
        public async Task<IActor> GetActorAsync(StringAttribute Actor, Variables Variables)
        {
            if (await this.GetActorObjectAsync(Actor, Variables) is IActor ActorRef)
                return ActorRef;
            else
                throw new Exception("Expected an actor: " + Actor);
        }
 
        private string lastActor = null;
        private Expression lastActorExpression = null;
        private readonly object synchObj = new object();
    }
}