Attribute.cs

using System;
using System.Xml;
using Waher.Script;
using Waher.Layout.Layout2D.Exceptions;
using System.Threading.Tasks;
 
namespace Waher.Layout.Layout2D.Model.Attributes
{
    public abstract class Attribute<T>
    {
        private T evaluatedValue = default;
        private bool hasEvaluated = false;
        private bool hasEvaluatedValue = false;
        private readonly T presetValue;
        private readonly bool hasPresetValue;
        private readonly Expression expression;
        private readonly string name;
        private readonly Layout2DDocument document;
 
        public Attribute(string AttributeName, T Value, Layout2DDocument Document)
        {
            this.name = AttributeName;
            this.presetValue = Value;
            this.hasPresetValue = true;
            this.expression = null;
            this.document = Document;
        }
 
        public Attribute(XmlElement E, string AttributeName, bool CanEmbedScript, Layout2DDocument Document)
        {
            this.name = AttributeName;
            this.document = Document;
 
            if (E.HasAttribute(this.name))
            {
                string Value = E.GetAttribute(this.name);
 
                int c = Value.Length;
 
                if (CanEmbedScript && c >= 2 && Value[0] == '{' && Value[c - 1] == '}')
                {
                    try
                    {
                        Expression Exp = new Expression(Value.Substring(1, c - 2));
                        
                        this.presetValue = default;
                        this.hasPresetValue = false;
                        this.expression = Exp;
                        Document.Dynamic = true;
 
                        return;
                    }
                    catch (Exception)
                    {
                        // Ignore
                    }
                }
 
                if (this.TryParse(Value, out T ParsedValue))
                {
                    this.presetValue = ParsedValue;
                    this.hasPresetValue = true;
                    this.expression = null;
                }
                else
                    throw new LayoutSyntaxException("Invalid value of attribute " + this.name + ": " + Value);
            }
            else
            {
                this.presetValue = default;
                this.expression = null;
                this.hasPresetValue = false;
            }
        }
 
        protected Attribute(string AttributeName, Expression Expression, Layout2DDocument Document)
        {
            this.name = AttributeName;
            this.presetValue = default;
            this.hasPresetValue = false;
            this.expression = Expression;
            this.document = Document;
 
            if (!(this.expression is null))
                this.document.Dynamic = true;
        }
 
        public string Name => this.name;
 
        public T PresetValue => this.presetValue;
 
        public Expression Expression => this.expression;
 
        public bool HasPresetValue => this.hasPresetValue;
 
        public bool HasExpression => !(this.expression is null);
 
        public bool Undefined => !this.hasPresetValue && this.expression is null;
 
        public bool Defined => this.hasPresetValue || !(this.expression is null);
 
        public Layout2DDocument Document => this.document;
 
        public abstract bool TryParse(string StringValue, out T Value);
 
        public virtual bool TryConvert(object Result, out T Value)
        {
            if (Result is string s && this.TryParse(s, out Value))
                return true;
            else
            {
                Value = default;
                return false;
            }
        }
 
        public abstract string ToString(T Value);
 
        public void Export(XmlWriter Output)
        {
            if (this.hasPresetValue)
                Output.WriteAttributeString(this.name, this.ToString(this.presetValue));
            else if (!(this.expression is null))
                Output.WriteAttributeString(this.name, "{" + this.expression.Script + "}");
        }
 
        public void ExportState(XmlWriter Output)
        {
            if (this.hasPresetValue)
                Output.WriteAttributeString(this.name, this.ToString(this.presetValue));
            else if (this.hasEvaluatedValue)
                Output.WriteAttributeString(this.name, this.ToString(this.evaluatedValue));
        }
 
        public async Task<T> EvaluateAsync(Variables Session, T DefaultValue)
        {
            if (this.hasPresetValue)
                return this.presetValue;
            else if (this.hasEvaluatedValue)
                return this.evaluatedValue;
            else if (this.hasEvaluated)
                return DefaultValue;
            else if (this.expression is null)
                return DefaultValue;
            else 
            {
                try
                {
                    object Value = await this.expression.EvaluateAsync(Session);
                    if (Value is T Eval || this.TryConvert(Value, out Eval))
                    {
                        this.evaluatedValue = Eval;
                        this.hasEvaluated = true;
                        this.hasEvaluatedValue = true;
 
                        return Eval;
                    }
                    else
                    {
                        this.hasEvaluated = true;
                        return DefaultValue;
                    }
                }
                catch (Exception)
                {
                    this.hasEvaluated = true;
                    return DefaultValue;
                }
            }
        }
 
        public static async Task<EvaluationResult<T>> TryEvaluate(Attribute<T> Attribute, Variables Session)
        {
            if (Attribute is null)
                return EvaluationResult<T>.Empty;
            else if (Attribute.hasPresetValue)
                return new EvaluationResult<T>(Attribute.presetValue);
            else if (Attribute.hasEvaluatedValue)
                return new EvaluationResult<T>(Attribute.evaluatedValue);
            else if (Attribute.hasEvaluated)
                return EvaluationResult<T>.Empty;
            else if (!(Attribute.expression is null))
            {
                try
                {
                    object Value = await Attribute.expression.EvaluateAsync(Session);
                    if (Value is T Eval || Attribute.TryConvert(Value, out Eval))
                    {
                        Attribute.evaluatedValue = Eval;
                        Attribute.hasEvaluated = true;
                        Attribute.hasEvaluatedValue = true;
 
                        return new EvaluationResult<T>(Eval);
                    }
                    else
                    {
                        Attribute.hasEvaluated = true;
                        return EvaluationResult<T>.Empty;
                    }
                }
                catch (Exception)
                {
                    Attribute.hasEvaluated = true;
                    return EvaluationResult<T>.Empty;
                }
            }
            else
                return EvaluationResult<T>.Empty;
        }
 
        public override string ToString()
        {
            if (this.hasPresetValue)
                return this.presetValue?.ToString();
            else if (this.hasEvaluatedValue)
                return this.evaluatedValue?.ToString();
            else if (this.hasEvaluated)
                return "<Evaluation error>";
            else if (!(this.expression is null))
                return this.expression.Script;
            else
                return "<Not set>";
        }
 
    }
}