ReportAttribute.cs

using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Script;
using Waher.Script.Exceptions;
 
namespace Waher.Reports.Model.Attributes
{
    public abstract class ReportAttribute<T>
    {
        private readonly string definition;
        private T constant;
        private Expression expression;
        private readonly bool isExpression;
        private bool first = true;
 
        public ReportAttribute(XmlElement Xml, string AttributeName)
        {
            if (string.IsNullOrEmpty(AttributeName))
                this.definition = Xml.InnerText;
            else
                this.definition = XML.Attribute(Xml, AttributeName);
 
            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 Task<T> Evaluate(Variables Variables, T DefaultValue)
        {
            if (this.IsEmpty)
                return Task.FromResult(DefaultValue);
            else
                return this.Evaluate(Variables);
        }
 
        public async Task<T> Evaluate(Variables Variables)
        {
            if (this.first)
            {
                if (this.isExpression)
                    this.expression = new Expression(this.definition[1..^1]);
                else
                    this.constant = this.ParseValue(this.definition);
 
                this.first = false;
            }
 
            if (this.isExpression)
            {
                object Result = await this.expression.EvaluateAsync(Variables);
 
                if (Result is T TypedResult)
                    return TypedResult;
                else if (Result is null)
                    return default;
                else
                {
                    StringBuilder sb = new StringBuilder();
 
                    sb.Append("Expected a value of type ");
                    sb.Append(typeof(T).FullName);
                    sb.Append(" but got a value of type ");
                    sb.Append(Result.GetType().FullName ?? "null");
                    sb.Append('.');
 
                    throw new ScriptRuntimeException(sb.ToString(), this.expression.Root);
                }
            }
            else
                return this.constant;
        }
    }
}