ScriptableAttribute.cs

using System;
using System.Threading.Tasks;
using Waher.Networking.XMPP.Server;
using Waher.Script;
using Waher.Script.Model;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Attributes
{
    public abstract class ScriptableAttribute<T>
    {
        private readonly StateMachineNode node;
        private readonly string definition;
        private T constant;
        private Expression expression;
        private readonly bool isExpression;
        private bool first = true;
 
        public ScriptableAttribute(string Definition, StateMachineNode Node)
        {
            this.node = Node;
            this.definition = Definition;
            this.isExpression = this.definition.StartsWith("{") && this.definition.EndsWith("}");
        }
 
        public string Definition => this.definition;
 
        public bool IsConstant => !this.isExpression;
 
        public bool IsExpression => this.isExpression;
 
        public bool IsEmpty => string.IsNullOrEmpty(this.definition);
 
        public abstract T ParseValue(string s);
 
        public async Task<T> Evaluate(Variables Variables)
        {
            if (this.first)
            {
                if (this.isExpression)
                {
                    string s = this.definition.Substring(1, this.definition.Length - 2);
                    Expression Exp = new Expression(s);
                    if (!XmppServer.CheckExpressionSafe(Exp, true, true, false, out ScriptNode Prohibited))
                        throw new UnauthorizedAccessException("Expression not permitted: " + Prohibited?.SubExpression);
 
                    this.expression = Exp;
                }
                else
                    this.constant = this.ParseValue(this.definition);
 
                this.first = false;
            }
 
            if (this.isExpression)
            {
                IContextVariables Bak = Variables.ContextVariables;
                try
                {
                    Variables.ContextVariables = this.node.StateMachine;
 
                    return (T)await this.expression.EvaluateAsync(Variables);
                }
                finally
                {
                    Variables.ContextVariables = Bak;
                }
            }
            else
                return this.constant;
        }
    }
}