NumericParameter.cs

using System;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Networking.XMPP.Contracts.HumanReadable;
 
namespace Waher.Networking.XMPP.Contracts
{
    public class NumericalParameter : RangeParameter<decimal>
    {
        public override string StringValue
        {
            get => this.Value.HasValue ? CommonTypes.Encode(this.Value.Value) : string.Empty;
            set
            {
                if (CommonTypes.TryParse(value, out decimal d))
                    this.Value = d;
                else
                    this.Value = null;
            }
        }
 
        public override string ParameterType => "numericalParameter";
 
        public override void Serialize(StringBuilder Xml, bool UsingTemplate)
        {
            Xml.Append("<numericalParameter");
 
            if (!UsingTemplate)
            {
                if (!string.IsNullOrEmpty(this.Expression))
                {
                    Xml.Append(" exp=\"");
                    Xml.Append(XML.Encode(this.Expression.Normalize(NormalizationForm.FormC)));
                    Xml.Append('"');
                }
 
                if (!string.IsNullOrEmpty(this.Guide))
                {
                    Xml.Append(" guide=\"");
                    Xml.Append(XML.Encode(this.Guide.Normalize(NormalizationForm.FormC)));
                    Xml.Append('"');
                }
 
                if (this.Max.HasValue)
                {
                    Xml.Append(" max=\"");
                    Xml.Append(CommonTypes.Encode(this.Max.Value));
                    Xml.Append("\" maxIncluded=\"");
                    Xml.Append(XML.Encode(CommonTypes.Encode(this.MaxIncluded)));
                    Xml.Append('"');
                }
 
                if (this.Min.HasValue)
                {
                    Xml.Append(" min=\"");
                    Xml.Append(CommonTypes.Encode(this.Min.Value));
                    Xml.Append("\" minIncluded=\"");
                    Xml.Append(XML.Encode(CommonTypes.Encode(this.MinIncluded)));
                    Xml.Append('"');
                }
            }
 
            Xml.Append(" name=\"");
            Xml.Append(XML.Encode(this.Name));
            Xml.Append('"');
 
            if (this.CanSerializeProtectedValue)
            {
                Xml.Append(" protected=\"");
                Xml.Append(Convert.ToBase64String(this.ProtectedValue));
                Xml.Append('"');
            }
 
            if (!UsingTemplate && this.Protection != ProtectionLevel.Normal)
            {
                Xml.Append(" protection=\"");
                Xml.Append(this.Protection.ToString());
                Xml.Append('"');
            }
 
            if (this.Value.HasValue && this.CanSerializeValue)
            {
                Xml.Append(" value=\"");
                Xml.Append(CommonTypes.Encode(this.Value.Value));
                Xml.Append('"');
            }
 
            if (UsingTemplate || this.Descriptions is null || this.Descriptions.Length == 0)
                Xml.Append("/>");
            else
            {
                Xml.Append('>');
 
                foreach (HumanReadableText Description in this.Descriptions)
                    Description.Serialize(Xml, "description", null);
 
                Xml.Append("</numericalParameter>");
            }
        }
 
        public override void SetValue(object Value)
        {
            this.Value = ToDecimal(Value);
        }
 
        public static decimal ToDecimal(object Value)
        {
            if (Value is double d)
                return (decimal)d;
            else if (Value is float f)
                return (decimal)f;
            else if (Value is decimal dec)
                return dec;
            else if (Value is int i)
                return i;
            else if (Value is long l)
                return l;
            else if (Value is short s)
                return s;
            else if (Value is sbyte sb)
                return sb;
            else if (Value is uint ui)
                return ui;
            else if (Value is ulong ul)
                return ul;
            else if (Value is ushort us)
                return us;
            else if (Value is byte ub)
                return ub;
            else if (Value is string str && CommonTypes.TryParse(str, out dec))
                return dec;
            else
                throw new ArgumentException("Invalid parameter type.", nameof(Value));
        }
 
        public override void SetMinValue(object Value, bool? Inclusive)
        {
            this.Min = ToDecimal(Value);
 
            if (Inclusive.HasValue)
                this.MinIncluded = Inclusive.Value;
        }
 
        public override void SetMaxValue(object Value, bool? Inclusive)
        {
            this.Max = ToDecimal(Value);
 
            if (Inclusive.HasValue)
                this.MaxIncluded = Inclusive.Value;
        }
 
        public override Task<bool> Import(XmlElement Xml)
        {
            this.Value = Xml.HasAttribute("value") ? XML.Attribute(Xml, "value", 0.0m) : (decimal?)null;
            this.Min = Xml.HasAttribute("min") ? XML.Attribute(Xml, "min", 0.0m) : (decimal?)null;
            this.MinIncluded = XML.Attribute(Xml, "minIncluded", true);
            this.Max = Xml.HasAttribute("max") ? XML.Attribute(Xml, "max", 0.0m) : (decimal?)null;
            this.MaxIncluded = XML.Attribute(Xml, "maxIncluded", true);
 
            return base.Import(Xml);
        }
 
    }
}