Variables.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
 
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 CancellationTokenSource cancellation = new CancellationTokenSource();
        private Stack<Dictionary<string, Variable>> stack = null;
        private TextWriter consoleOut = null;
        private IContextVariables contextVariables = null;
        private volatile bool active = true;
        private ValuePrinter printer = null;
 
        public Variables(params Variable[] Variables)
        {
            if ((Variables?.Length ?? 0) > 0)
            {
                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;
        }
 
        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()
        {
            if (this.active)
            {
                this.active = false;
                this.cancellation.Cancel();
            }
        }
 
        public void CancelAbort()
        {
            if (!this.active)
            {
                this.active = true;
                this.cancellation = new CancellationTokenSource();
            }
        }
 
        public bool Aborted => !this.active;
 
        public bool Active => this.active;
 
        public event EventHandlerAsync<PreviewEventArgs> 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 async Task Preview(Expression Expression, IElement Result)
        {
            EventHandlerAsync<PreviewEventArgs> h = this.OnPreview;
 
            if (!(h is null))
                await h.Raise(this, new PreviewEventArgs(Expression, this, Result));
 
            if (this.contextVariables is Variables v)
                await v.Preview(Expression, Result);
        }
 
 
        public async Task Status(Expression Expression, string Result)
        {
            EventHandlerAsync<StatusEventArgs> h = this.OnStatus;
            if (!(h is null))
                await h(this, new StatusEventArgs(Expression, this, Result));
        }
 
        public bool HandlesStatus => !(this.OnStatus is null);
 
        public event EventHandlerAsync<StatusEventArgs> OnStatus = null;
 
        public CancellationToken CancellationToken => this.cancellation.Token;
    }
}