CustomGraph.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using TAG.Simulator.Statistics;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Script.Objects;
using Waher.Script.Units;
 
namespace TAG.Simulator.ObjectModel.Graphs
{
    public class CustomGraph : Graph, ICustomGraph, IBucket
    {
        private readonly LinkedList<KeyValuePair<DateTime, double>> statistics = new LinkedList<KeyValuePair<DateTime, double>>();
        private string @for;
        private string script;
        private StringBuilder times = null;
        private StringBuilder values = null;
        private IFilter filter = null;
        private DateTime start;
        private DateTime stop;
        private Duration bucketTime;
        private Unit unit = null;
        private int count = 0;
        private long last = 0;
 
        public CustomGraph(ISimulationNode Parent, Model Model)
            : base(Parent, Model)
        {
        }
 
        public override string LocalName => nameof(CustomGraph);
 
        public string For => this.@for;
 
        public string Id => this.For;
 
        public long TotalCount => this.count;
 
        public Duration BucketTime
        {
            get => this.bucketTime;
            set => this.bucketTime = value;
        }
 
        public override ISimulationNode Create(ISimulationNode Parent, Model Model)
        {
            return new CustomGraph(Parent, Model);
        }
 
        public override bool ParseChildren => false;
 
        public override Task FromXml(XmlElement Definition)
        {
            this.@for = XML.Attribute(Definition, "for");
 
            if (Definition.HasAttribute("timeVariable"))
            {
                this.times = new StringBuilder();
                this.times.Append(Definition.GetAttribute("timeVariable"));
                this.times.Append(":=[");
            }
 
            this.values = new StringBuilder();
 
            if (Definition.HasAttribute("valueVariable"))
                this.values.Append(Definition.GetAttribute("valueVariable"));
            else
                this.values.Append(this.@for);
 
            this.values.Append(":=[");
 
            this.script = Values.Script.RemoveIndent(Definition.InnerText);
 
            return Task.CompletedTask;
        }
 
        public override Task Start()
        {
            this.start = this.Model.StartTime;
            this.bucketTime = this.Model.BucketTime;
            this.stop = this.start + this.bucketTime;
 
            return base.Start();
        }
 
        public DateTime Inc()
        {
            DateTime Timestamp = DateTime.Now;
            double v;
 
            lock (this)
            {
                v = ++this.last;
            }
 
            return this.Sample(Timestamp, v);
        }
 
        public DateTime Dec()
        {
            DateTime Timestamp = DateTime.Now;
            double v;
 
            lock (this)
            {
                v = --this.last;
            }
 
            return this.Sample(Timestamp, v);
        }
 
        public DateTime Sample(DateTime Timestamp, PhysicalQuantity Value)
        {
            double v;
 
            if (this.unit is null)
            {
                this.unit = Value.Unit;
                v = Value.Magnitude;
            }
            else if (!Unit.TryConvert(Value.Magnitude, Value.Unit, this.unit, out v))
                throw new Exception("Incompatible units: " + Value.Unit.ToString() + " and " + this.unit.ToString());
 
            return this.Sample(Timestamp, v);
        }
 
        public DateTime Sample(DateTime Timestamp, double Value)
        {
            if (this.filter?.Filter(ref Timestamp, ref Value) ?? false)
                return this.start;
 
            lock (this)
            {
                while (Timestamp >= this.stop)
                {
                    this.start = this.stop;
                    this.stop = this.start + this.bucketTime;
                }
 
                if (!(this.times is null))
                {
                    if (this.count > 0)
                        this.times.Append(',');
 
                    this.times.Append(CommonTypes.Encode(this.Model.GetTimeCoordinates(Timestamp)));
                }
 
                if (!(this.values is null))
                {
                    if (this.count > 0)
                        this.values.Append(',');
 
                    this.values.Append(CommonTypes.Encode(Value));
                }
 
                this.statistics.AddLast(new KeyValuePair<DateTime, double>(Timestamp, Value));
                this.count++;
 
                return this.start;
            }
        }
 
        public DateTime CountOccurrence(DateTime Timestamp)
        {
            double v;
 
            lock (this)
            {
                v = ++this.last;
            }
 
            return this.Sample(Timestamp, v);
        }
 
        public void Flush()
        {
        }
 
        public void ExportXml(XmlWriter Output, string RowElement)
        {
            this.Flush();
 
            lock (this)
            {
                Output.WriteStartElement(RowElement);
                Output.WriteAttributeString("type", this.@for);
                Output.WriteAttributeString("count", this.count.ToString());
 
                if (!(this.unit is null))
                    Output.WriteAttributeString("unit", this.unit.ToString());
 
                foreach (KeyValuePair<DateTime, double> Rec in this.statistics)
                {
                    Output.WriteStartElement("Stat");
                    Output.WriteAttributeString("ts", XML.Encode(Rec.Key));
                    Output.WriteAttributeString("value", CommonTypes.Encode(Rec.Value));
                    Output.WriteEndElement();
                }
 
                Output.WriteEndElement();
            }
        }
 
        public override void ExportGraph(StreamWriter Output)
        {
            this.Flush();
 
            lock (this)
            {
                Output.WriteLine("{");
 
                if (this.count > 0)
                {
                    if (!(this.times is null))
                    {
                        Output.Write(this.times.ToString());
                        Output.WriteLine("];");
                    }
 
                    if (!(this.values is null))
                    {
                        Output.Write(this.values.ToString());
                        Output.WriteLine("];");
                    }
                }
 
                Output.WriteLine("GraphWidth:=1000;");
                Output.WriteLine("GraphHeight:=400;");
                this.ExportGraphScript(Output, null, true);
                Output.WriteLine(";");
                Output.WriteLine("}");
                Output.WriteLine();
            }
        }
 
        public override bool ExportGraphScript(StreamWriter Output, string CustomColor, bool Span)
        {
            string s = this.script.Trim();
            if (!string.IsNullOrEmpty(s) && ";|<>/\\]}".IndexOf(s[s.Length - 1]) >= 0)
                s = s.Substring(0, s.Length - 1);
 
            Output.Write(s);
 
            return true;
        }
 
        public void Add(IFilter Filter)
        {
            if (this.filter is null)
                this.filter = Filter;
            else
                this.filter.Append(Filter);
        }
 
    }
}