Variables.cs

using System;
using System.IO;
using System.Collections.Generic;
using System.Threading;
using Waher.Script.Exceptions;
using System.Collections;
using System.Threading.Tasks;
using Waher.Script.Abstraction.Elements;
using Waher.Events;
 
namespace Waher.Script
{
    public delegate Task<string> ValuePrinter(object Value, Variables Variables);
 
    public class Variables : IEnumerable<Variable>, IContextVariables
    {
        protected Dictionary<string, Variable> variables = new Dictionary<string, Variable>();
        private Stack<Dictionary<string, Variable>> stack = null;
        private TextWriter consoleOut = null;
        private IContextVariables contextVariables = null;
        private readonly SemaphoreSlim semaphore = new SemaphoreSlim(1);
        private volatile bool active = true;
        private ValuePrinter printer = null;
 
        public Variables(params Variable[] Variables)
        {
            foreach (Variable Variable in Variables)
                this.variables[Variable.Name] = Variable;
        }
 
        public virtual bool TryGetVariable(string Name, out Variable Variable)
        {
            if (this.active)
            {
                lock (this.variables)
                {
                    if (this.variables.TryGetValue(Name, out Variable))
                        return true;
                }
 
                if (!(this.contextVariables is null))
                    return this.contextVariables.TryGetVariable(Name, out Variable);
 
                return false;
            }
            else
                throw new ScriptAbortedException();
        }
 
        public virtual bool ContainsVariable(string Name)
        {
            if (this.active)
            {
                lock (this.variables)
                {
                    if (this.variables.ContainsKey(Name))
                        return true;
                }
 
                if (!(this.contextVariables is null))
                    return this.contextVariables.ContainsVariable(Name);
 
                return false;
            }
            else
                throw new ScriptAbortedException();
        }
 
        public object this[string Name]
        {
            get
            {
                if (this.TryGetVariable(Name, out Variable v))
                    return v.ValueObject;
                else
                    return null;
            }
 
            set
            {
                this.Add(Name, value);
            }
        }
 
        public virtual Variable Add(string Name, object Value)
        {
            Variable Result;
 
            if (this.active)
            {
                lock (this.variables)
                {
                    if (this.variables.TryGetValue(Name, out Result))
                        Result.SetValue(Value);
                    else
                        this.variables[Name] = Result = new Variable(Name, Value);
                }
            }
            else
                throw new ScriptAbortedException();
 
            return Result;
        }
 
        public virtual bool Remove(string VariableName)
        {
            if (this.active)
            {
                lock (this.variables)
                {
                    return this.variables.Remove(VariableName);
                }
            }
            else
                throw new ScriptAbortedException();
        }
 
        public virtual void Clear()
        {
            if (this.active)
            {
                lock (this.variables)
                {
                    this.variables.Clear();
                }
            }
            else
                throw new ScriptAbortedException();
        }
 
        public virtual void Push()
        {
            if (this.active)
            {
                if (this.stack is null)
                    this.stack = new Stack<Dictionary<string, Variable>>();
 
                this.stack.Push(this.variables);
 
                Dictionary<string, Variable> Clone = new Dictionary<string, Variable>();
                foreach (KeyValuePair<string, Variable> P in this.variables)
                    Clone[P.Key] = new Variable(P.Key, P.Value.ValueElement);
 
                this.variables = Clone;
            }
            else
                throw new ScriptAbortedException();
        }
 
        public virtual void Pop()
        {
            if (this.active)
            {
                if (this.stack is null)
                    throw new ScriptException("Stack is empty.");
 
                this.variables = this.stack.Pop();
            }
            else
                throw new ScriptAbortedException();
        }
 
        public TextWriter ConsoleOut
        {
            get => this.consoleOut;
            set => this.consoleOut = value;
        }
 
        public IContextVariables ContextVariables
        {
            get => this.contextVariables;
            set => this.contextVariables = value;
        }
 
        public ValuePrinter Printer
        {
            get => this.printer;
            set => this.printer = value;
        }
 
        [Obsolete("Use the LockAsync method for better performance of processing asynchronous tasks.")]
        public void Lock()
        {
            this.Lock(30000);
        }
 
        public Task LockAsync()
        {
            return this.LockAsync(30000);
        }
 
        [Obsolete("Use the LockAsync method for better performance of processing asynchronous tasks.")]
        public void Lock(int Timeout)
        {
            this.LockAsync(Timeout).Wait();
        }
 
        public async Task LockAsync(int Timeout)
        {
            if (this.active)
            {
                if (!await this.semaphore.WaitAsync(Timeout))
                    throw new TimeoutException("Unique access to variables connection was not granted.");
            }
            else
                throw new ScriptAbortedException();
        }
 
        public void Release()
        {
            this.semaphore.Release();
        }
 
        public Variable[] AvailableVariables
        {
            get
            {
                if (this.active)
                {
                    Variable[] Variables;
 
                    lock (this.variables)
                    {
                        Variables = new Variable[this.variables.Count];
                        this.variables.Values.CopyTo(Variables, 0);
                    }
 
                    return Variables;
                }
                else
                    throw new ScriptAbortedException();
            }
        }
 
        public IEnumerator<Variable> GetEnumerator()
        {
            return new VariableEnumerator(this.AvailableVariables);
        }
 
        private class VariableEnumerator : IEnumerator<Variable>
        {
            private readonly Variable[] variables;
            private int pos = -1;
 
            internal VariableEnumerator(Variable[] Variables)
            {
                this.variables = Variables;
            }
 
            public Variable Current
            {
                get
                {
                    return this.variables[this.pos];
                }
            }
 
            object IEnumerator.Current
            {
                get
                {
                    return this.variables[this.pos];
                }
            }
 
            public void Dispose()
            {
            }
 
            public bool MoveNext()
            {
                return ++this.pos < this.variables.Length;
            }
 
            public void Reset()
            {
                this.pos = -1;
            }
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.AvailableVariables.GetEnumerator();
        }
 
        public void CopyTo(Variables Variables)
        {
            Variable[] VariablesToCopy = this.AvailableVariables;
            Dictionary<string, Variable> Recipient = Variables.variables;
 
            lock (Recipient)
            {
                foreach (Variable Variable in VariablesToCopy)
                    Recipient[Variable.Name] = Variable;
            }
        }
 
        public void Abort()
        {
            this.active = false;
        }
 
        public void CancelAbort()
        {
            this.active = true;
        }
 
        public event PreviewEventHandler OnPreview;
 
        public bool HandlesPreview
        {
            get
            {
                if (!(this.OnPreview is null))
                    return true;
 
                if (this.contextVariables is Variables v)
                    return v.HandlesPreview;
                else
                    return false;
            }
        }
 
        public void Preview(Expression Expression, IElement Result)
        {
            PreviewEventHandler h = this.OnPreview;
 
            if (!(h is null))
            {
                try
                {
                    h(this, new PreviewEventArgs(Expression, this, Result));
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
 
            if (this.contextVariables is Variables v)
                v.Preview(Expression, Result);
        }
 
 
        public void Status(Expression Expression, string Result)
        {
            StatusEventHandler h = this.OnStatus;
            if (!(h is null))
            {
                try
                {
                    h(this, new StatusEventArgs(Expression, this, Result));
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
        }
 
        public bool HandlesStatus
        {
            get { return !(this.OnStatus is null); }
        }
 
        public event StatusEventHandler OnStatus = null;
 
    }
}