ActorReference.cs

using System;
using System.Collections.Generic;
using System.IO;
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 ActorReference : EventPreparation, IActors
    {
        private readonly List<IActor> actors = new List<IActor>();
        private IActor[] actorsStat;
        private int count;
        private string name;
        private string name2;
        private bool exclusive;
 
        public ActorReference(ISimulationNode Parent, Model Model)
            : base(Parent, Model)
        {
        }
 
        public override string LocalName => nameof(ActorReference);
 
        public string Name => this.name;
 
        public bool Exclusive => this.exclusive;
 
        public override ISimulationNode Create(ISimulationNode Parent, Model Model)
        {
            return new ActorReference(Parent, Model);
        }
 
        public override Task FromXml(XmlElement Definition)
        {
            this.name = XML.Attribute(Definition, "name");
            this.exclusive = XML.Attribute(Definition, "exclusive", true);
 
            return base.FromXml(Definition);
        }
 
        public void Register(IActor Actor)
        {
            this.actors.Add(Actor);
        }
 
        public override Task Start()
        {
            this.actorsStat = this.actors.ToArray();
            this.count = this.actorsStat.Length;
            this.name2 = this.name + " Actor";
 
            return base.Start();
        }
 
        public override Task Prepare(Variables Variables, List<KeyValuePair<string, object>> Tags)
        {
            IActor Actor;
            int[] P = new int[this.count];
            int i, j;
 
            lock (this.Model)
            {
                for (i = j = 0; i < this.count; i++)
                {
                    j += this.actorsStat[i].FreeCount;
                    P[i] = j;
                }
 
                if (j <= 0)
                    throw new Exception("No free individual available in population.");
 
                j = this.Model.GetRandomInteger(j);
                i = 0;
 
                while (P[i] <= j)
                    i++;
 
                if (i > 0)
                    j -= P[i - 1];
 
                Actor = this.actorsStat[i].GetFreeIndividual(j, this.exclusive);
            }
 
            Variables[this.name2] = Actor;
            Variables[this.name] = Actor.ActivityObject;
 
            Tags.Add(new KeyValuePair<string, object>(this.name, Actor.InstanceId));
 
            return Task.CompletedTask;
        }
 
        public override void Release(Variables Variables)
        {
            if (this.exclusive &&
                Variables.TryGetVariable(this.name2, out Variable v) &&
                v.ValueObject is IActor InstanceActor &&
                InstanceActor.Parent is IActor ActorPopulation)
            {
                lock (this.Model)
                {
                    ActorPopulation.ReturnIndividual(InstanceActor);
                }
 
                Variables.Remove(this.name2);
            }
        }
 
        public override void ExportPlantUml(StreamWriter Output, string Name, int Index)
        {
            int i = 0;
 
            foreach (IActor Actor in this.actors)
            {
                string s = this.name + "_" + Index.ToString() + "_A" + i.ToString();
 
                Output.Write("actor \"");
                Output.Write(this.name);
                Output.Write("\" as ");
                Output.Write(s);
                Output.Write(" <<");
                Output.Write(Actor.Id);
                Output.WriteLine(">>");
 
                Actor.AnnotateActorUseCaseUml(Output, s);
 
                Output.Write(s);
                Output.Write(" --> UC");
                Output.Write(Index.ToString());
 
                if (!string.IsNullOrEmpty(Name))
                {
                    Output.Write(" : ");
                    Output.Write(Name);
                }
 
                Output.WriteLine();
 
                i++;
            }
        }
 
    }
}