ExternalEvent.cs

using System;
using System.Collections.Generic;
using System.Net.NetworkInformation;
using System.Threading.Tasks;
using System.Xml;
using TAG.Simulator.ObjectModel.Actors;
using Waher.Content.Xml;
using Waher.Script;
 
namespace TAG.Simulator.ObjectModel.Events
{
    public class ExternalEvent : SimulationNodeChildren, IExternalEvent
    {
        private Dictionary<string, Parameter> parameters = null;
        private IEvent eventReference;
        private IExternalEventsNode events;
        private string name;
        private string eventId;
        private string actorName;
 
        public ExternalEvent(ISimulationNode Parent, Model Model)
            : base(Parent, Model)
        {
        }
 
        public string Name => this.name;
 
        public string EventId => this.eventId;
 
        public string ActorName => this.actorName;
 
        public IExternalEventsNode Events => this.events;
 
        public IEvent Event => this.eventReference;
 
        public override string LocalName => nameof(ExternalEvent);
 
        public IEnumerable<Parameter> Parameters => this.parameters?.Values;
 
        public override ISimulationNode Create(ISimulationNode Parent, Model Model)
        {
            return new ExternalEvent(Parent, Model);
        }
 
        public override Task FromXml(XmlElement Definition)
        {
            this.name = XML.Attribute(Definition, "name");
            this.eventId = XML.Attribute(Definition, "event");
            this.actorName = XML.Attribute(Definition, "actorName");
 
            return base.FromXml(Definition);
        }
 
        public override Task Initialize()
        {
            ISimulationNode Loop = this.Parent;
 
            while (!(Loop is null))
            {
                if (Loop is IExternalEventsNode Events)
                {
                    this.events = Events;
                    this.events.Register(this);
                    break;
                }
                else
                    Loop = Loop.Parent;
            }
 
            if (Loop is null)
                throw new Exception("External event registered on a node that is not hosted by an actor.");
 
            return Task.CompletedTask;
        }
 
        public override Task Start()
        {
            if (!this.Model.TryGetEvent(this.eventId, out this.eventReference))
                throw new Exception("Event node not found: " + this.eventId);
 
            this.eventReference.Register(this);
 
            return base.Start();
        }
 
        public void Register(Parameter Parameter)
        {
            string Name = Parameter.Name;
 
            if (this.parameters is null)
                this.parameters = new Dictionary<string, Parameter>();
 
            if (this.parameters.ContainsKey(Name))
                throw new Exception("A parameter named " + Name + " has already been registered for external event " + this.eventId);
 
            this.parameters[Name] = Parameter;
        }
 
        public void Trigger(IActor Source, params KeyValuePair<string, object>[] Arguments)
        {
            Variables Variables = this.Model.GetEventVariables(Source);
 
            if (!string.IsNullOrEmpty(this.actorName))
                Variables[this.actorName] = Source.ActivityObject;
 
            if (!(this.parameters is null))
            {
                string Name;
 
                foreach (KeyValuePair<string, object> P in Arguments)
                {
                    if (this.parameters.TryGetValue(P.Key, out Parameter P2))
                    {
                        Name = P2.Variable;
                        if (string.IsNullOrEmpty(Name))
                            Name = P2.Name;
 
                        Variables[Name] = P.Value;
                    }
                }
            }
 
            this.eventReference.Trigger(Variables);
        }
 
    }
}