CurrentState.cs

using System;
using System.Collections.Generic;
using Waher.Content;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Script;
using Waher.Service.IoTBroker.NeuroFeatures;
 
namespace Waher.Service.IoTBroker.StateMachines
{
    [CollectionName("StateMachineCurrentStates")]
    [TypeName(TypeNameSerialization.None)]
    [ArchivingTime(nameof(ArchiveDays))]
    [Index("StateMachineId")]
    public class CurrentState
    {
        private readonly object synchObj = new object();
        private Dictionary<string, CurrentStateVariable> variablesByName;
        private Dictionary<CaseInsensitiveString, bool> sourcesByName;
 
        public CurrentState()
        {
        }
 
        [ObjectId]
        public string ObjectId { get; set; }
 
        public string StateMachineId { get; set; }
 
        public string State { get; set; }
 
        public bool HasEnded => string.IsNullOrEmpty(this.State);
 
        public bool IsRunning => !string.IsNullOrEmpty(this.State);
 
        public CurrentStateVariable[] VariableValues { get; set; }
 
        public CaseInsensitiveString[] Sources { get; set; }
 
        public DateTime Expires { get; set; }
 
        [DefaultValueNull]
        public Duration? ArchiveRequired { get; set; }
 
        [DefaultValueNull]
        public Duration? ArchiveOptional { get; set; }
 
        public int ArchiveDays => Token.CalcArchiveDays(this.Expires, this.ArchiveRequired, this.ArchiveOptional);
 
        #region Variables
 
        public void SetVariable(string Name, object Value)
        {
            lock (this.synchObj)
            {
                if (this.VariableValues is null)
                {
                    this.VariableValues = new CurrentStateVariable[]
                    {
                        new CurrentStateVariable(Name, Value, null)
                    };
 
                    this.variablesByName = null;
                }
                else
                {
                    if (this.variablesByName is null)
                        this.SortVariablesLocked();
 
                    if (this.variablesByName.TryGetValue(Name, out CurrentStateVariable V))
                    {
                        V.Value = Value;
                        return;
                    }
 
                    int c = this.VariableValues.Length;
 
                    CurrentStateVariable[] Updated = new CurrentStateVariable[c + 1];
                    Array.Copy(this.VariableValues, 0, Updated, 0, c);
                    Updated[c] = V = new CurrentStateVariable(Name, Value, null);
 
                    this.VariableValues = Updated;
                    this.variablesByName[Name] = V;
                }
            }
        }
 
        public Variables GetVariables(StateMachine Machine)
        {
            lock (this.synchObj)
            {
                Variables Variables = HttpServer.CreateVariables();
                Variables.ContextVariables = Machine;
                Variables["CurrentState"] = this;
 
                if (!(this.VariableValues is null))
                {
                    foreach (CurrentStateVariable Variable in this.VariableValues)
                        Variables[Variable.Name] = Variable.Value;
                }
 
                return Variables;
            }
        }
 
        public bool TryGetVariable(string Name, out CurrentStateVariable Variable)
        {
            lock (this.synchObj)
            {
                if (this.variablesByName is null)
                    this.SortVariablesLocked();
 
                return this.variablesByName.TryGetValue(Name, out Variable);
            }
        }
 
        private void SortVariablesLocked()
        {
            Dictionary<string, CurrentStateVariable> Sorted = new Dictionary<string, CurrentStateVariable>();
 
            if (!(this.VariableValues is null))
            {
                foreach (CurrentStateVariable Variable2 in this.VariableValues)
                    Sorted[Variable2.Name] = Variable2;
            }
 
            this.variablesByName = Sorted;
        }
 
        #endregion
 
        #region Sources
 
        public bool AddSource(CaseInsensitiveString Name)
        {
            lock (this.synchObj)
            {
                if (this.Sources is null)
                {
                    this.Sources = new CaseInsensitiveString[] { Name };
                    this.sourcesByName = null;
                    
                    return true;
                }
                else
                {
                    if (this.sourcesByName is null)
                        this.SortSourcesLocked();
 
                    if (this.sourcesByName.ContainsKey(Name))
                        return false;
 
                    int c = this.Sources.Length;
 
                    CaseInsensitiveString[] Updated = new CaseInsensitiveString[c + 1];
                    Array.Copy(this.Sources, 0, Updated, 0, c);
                    Updated[c] = Name;
 
                    this.Sources = Updated;
                    this.sourcesByName[Name] = true;
 
                    return true;
                }
            }
        }
 
        public bool RemoveSource(CaseInsensitiveString Name)
        {
            lock (this.synchObj)
            {
                if (this.Sources is null)
                    return false;
 
                if (!(this.sourcesByName is null) && !this.sourcesByName.Remove(Name))
                    return false;
 
                int i = Array.IndexOf(this.Sources, Name);
                if (i < 0)
                    return false;
 
                int c = this.Sources.Length;
 
                CaseInsensitiveString[] Updated = new CaseInsensitiveString[c - 1];
 
                if (i > 0)
                    Array.Copy(this.Sources, 0, Updated, 0, i);
 
                if (i < c - 1)
                    Array.Copy(this.Sources, i + 1, Updated, i, c - i - 1);
 
                this.Sources = Updated;
 
                return true;
            }
        }
 
        public bool ContainsSource(CaseInsensitiveString Name)
        {
            lock (this.synchObj)
            {
                if (this.sourcesByName is null)
                    this.SortSourcesLocked();
 
                return this.sourcesByName.ContainsKey(Name);
            }
        }
 
        private void SortSourcesLocked()
        {
            Dictionary<CaseInsensitiveString, bool> Sorted = new Dictionary<CaseInsensitiveString, bool>();
 
            if (!(this.Sources is null))
            {
                foreach (CaseInsensitiveString Source2 in this.Sources)
                    Sorted[Source2] = true;
            }
 
            this.sourcesByName = Sorted;
        }
 
        #endregion
 
    }
}