TimerActor.cs

using System;
using System.IO;
using System.Threading;
using System.Xml;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Xml;
 
namespace TAG.Simulator.ObjectModel.Actors
{
    public class TimerActor : Actor
    {
        private Duration period;
        private bool isPeriodic;
        private Timer timer;
 
        public TimerActor(ISimulationNode Parent, Model Model)
            : base(Parent, Model)
        {
        }
 
        public TimerActor(ISimulationNode Parent, Model Model, int InstanceIndex, string InstanceId)
            : base(Parent, Model, InstanceIndex, InstanceId)
        {
        }
 
        public override string LocalName => nameof(Timer);
 
        public override ISimulationNode Create(ISimulationNode Parent, Model Model)
        {
            return new TimerActor(Parent, Model);
        }
 
        public override Task FromXml(XmlElement Definition)
        {
            this.period = XML.Attribute(Definition, "period", Duration.Zero);
            this.isPeriodic = this.period > Duration.Zero;
 
            return base.FromXml(Definition);
        }
 
        public override Task<Actor> CreateInstanceAsync(int InstanceIndex, string InstanceId)
        {
            return Task.FromResult<Actor>(new TimerActor(this, this.Model, InstanceIndex, InstanceId)
            {
                period = this.period,
                isPeriodic = this.isPeriodic
            });
        }
 
        public override Task InitializeInstance()
        {
            return Task.CompletedTask;
        }
 
        private void TimerCallback(object State)
        {
            this.Model.ExternalEvent(this, "Elapsed");
        }
 
        public override Task StartInstance()
        {
            if (this.isPeriodic)
            {
                DateTime Now = DateTime.Now;
                DateTime TP = Now + this.period;
                TimeSpan TS = TP - Now;
 
                this.timer = new Timer(this.TimerCallback, null, TS, TS);
            }
 
            return Task.CompletedTask;
        }
 
        public override Task FinalizeInstance()
        {
            this.timer?.Dispose();
            this.timer = null;
 
            return Task.CompletedTask;
        }
 
        public override void AnnotateActorUseCaseUml(StreamWriter Output, string Id)
        {
            if (this.isPeriodic)
            {
                Output.Write("note right of ");
                Output.Write(Id);
                Output.Write(" : Elapses periodically every ");
 
                Values.Duration.ExportText(this.period, Output);
 
                Output.WriteLine();
            }
        }
 
    }
}