DoubleAttribute.cs

using System;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Script;
 
namespace TAG.Simulator.ObjectModel
{
    public class DoubleAttribute
    {
        private readonly Expression expression;
        private readonly string name;
        private readonly string value;
        private readonly double parsed;
        private readonly bool hasEmbeddedScript;
        private readonly bool isOnlyScript;
 
        public DoubleAttribute(string Name, string Value)
        {
            this.name = Name;
            this.value = Value;
            this.hasEmbeddedScript = false;
            this.isOnlyScript = false;
            this.expression = null;
 
            int i = Value.IndexOf('{');
            if (i >= 0)
            {
                int j = Value.IndexOf('}', i + 1);
                this.hasEmbeddedScript = j > i;
                this.isOnlyScript = this.hasEmbeddedScript && i == 0 && j == Value.Length - 1;
                if (this.isOnlyScript)
                    this.expression = new Expression(Value.Substring(1, j - i - 1));
            }
 
            if (!this.hasEmbeddedScript && !CommonTypes.TryParse(Value, out this.parsed))
                throw new Exception("Invalid double value: " + Value);
        }
 
        public string Name => this.name;
 
        public double Value => this.parsed;
 
        public async Task<double> GetValueAsync(Variables Variables)
        {
            if (!this.hasEmbeddedScript)
                return this.parsed;
 
            if (this.isOnlyScript)
            {
                object Obj = await this.expression.EvaluateAsync(Variables);
                return Expression.ToDouble(Obj);
            }
            else
            {
                string s = await Expression.TransformAsync(this.value, "{", "}", Variables);
 
                if (!CommonTypes.TryParse(s, out double d))
                    throw new Exception("Invalid double value: " + s);
 
                return d;
            }
        }
 
        public async Task<byte> GetUInt8ValueAsync(Variables Variables)
        {
            double d = await this.GetValueAsync(Variables);
            if (d < byte.MinValue || d > byte.MaxValue)
                throw new ArgumentOutOfRangeException(this.name, d, "Out of byte range.");
 
            return (byte)d;
        }
 
        public async Task<ushort> GetUInt16ValueAsync(Variables Variables)
        {
            double d = await this.GetValueAsync(Variables);
            if (d < ushort.MinValue || d > ushort.MaxValue)
                throw new ArgumentOutOfRangeException(this.name, d, "Out of ushort range.");
 
            return (ushort)d;
        }
 
        public async Task<uint> GetUInt32ValueAsync(Variables Variables)
        {
            double d = await this.GetValueAsync(Variables);
            if (d < uint.MinValue || d > uint.MaxValue)
                throw new ArgumentOutOfRangeException(this.name, d, "Out of uint range.");
 
            return (uint)d;
        }
 
        public async Task<ulong> GetUInt64ValueAsync(Variables Variables)
        {
            double d = await this.GetValueAsync(Variables);
            if (d < ulong.MinValue || d > ulong.MaxValue)
                throw new ArgumentOutOfRangeException(this.name, d, "Out of ulong range.");
 
            return (ulong)d;
        }
 
        public async Task<sbyte> GetInt8ValueAsync(Variables Variables)
        {
            double d = await this.GetValueAsync(Variables);
            if (d < sbyte.MinValue || d > sbyte.MaxValue)
                throw new ArgumentOutOfRangeException(this.name, d, "Out of sbyte range.");
 
            return (sbyte)d;
        }
 
        public async Task<short> GetInt16ValueAsync(Variables Variables)
        {
            double d = await this.GetValueAsync(Variables);
            if (d < short.MinValue || d > short.MaxValue)
                throw new ArgumentOutOfRangeException(this.name, d, "Out of short range.");
 
            return (short)d;
        }
 
        public async Task<int> GetInt32ValueAsync(Variables Variables)
        {
            double d = await this.GetValueAsync(Variables);
            if (d < int.MinValue || d > int.MaxValue)
                throw new ArgumentOutOfRangeException(this.name, d, "Out of int range.");
 
            return (int)d;
        }
 
        public async Task<long> GetInt64ValueAsync(Variables Variables)
        {
            double d = await this.GetValueAsync(Variables);
            if (d < long.MinValue || d > long.MaxValue)
                throw new ArgumentOutOfRangeException(this.name, d, "Out of long range.");
 
            return (long)d;
        }
    }
}