QuantityLiteral.cs

using System;
using Waher.Content;
using Waher.Content.Semantic;
using Waher.Content.Semantic.Model;
using Waher.Content.Semantic.Model.Literals;
using Waher.Runtime.Inventory;
using Waher.Script.Objects;
using Waher.Script.Units;
using Waher.Things.Semantic.Ontologies;
 
namespace Waher.Things.Semantic
{
    public class QuantityLiteral : SemanticLiteral
    {
        private readonly PhysicalQuantity value;
        private readonly string stringType;
 
        public QuantityLiteral()
            : base(string.Empty, string.Empty)
        {
        }
 
        public QuantityLiteral(PhysicalQuantity Value)
            : base(Value.Magnitude, CommonTypes.Encode(Value.Magnitude))
        {
            this.value = Value;
            this.stringType = IoTSensorData.UnitNamespace + this.value?.Unit;
        }
 
        public override string StringType => this.stringType;
 
        public override ISemanticLiteral Encapsulate(object Value)
        {
            if (Value is IPhysicalQuantity Typed)
                return new QuantityLiteral(Typed.ToPhysicalQuantity());
            else
                return new StringLiteral(Value?.ToString() ?? string.Empty);
        }
 
        public override bool Equals(object obj)
        {
            return obj is QuantityLiteral Typed &&
                (this.value?.Equals(Typed.value) ?? Typed.value is null);
        }
 
        public override int GetHashCode()
        {
            return this.value.GetHashCode();
        }
 
        public override object AssociatedObjectValue => this.value;
 
        public override ISemanticLiteral Parse(string Value, string DataType, string Language)
        {
            if (DataType.StartsWith(IoTSensorData.UnitNamespace, StringComparison.CurrentCultureIgnoreCase) &&
                CommonTypes.TryParse(Value, out double Magnitude) &&
                Unit.TryParse(DataType.Substring(IoTSensorData.UnitNamespace.Length), out Unit Unit2))
            {
                return new QuantityLiteral(new PhysicalQuantity(Magnitude, Unit2));
            }
            else
                return new CustomLiteral(Value, DataType, Language);
        }
 
        public override Grade Supports(string DataType)
        {
            if (DataType.StartsWith(IoTSensorData.UnitNamespace, StringComparison.CurrentCultureIgnoreCase) &&
                Unit.TryParse(DataType.Substring(IoTSensorData.UnitNamespace.Length), out _))
            {
                return Grade.Ok;
            }
            else
                return Grade.NotAtAll;
        }
 
        public override Grade Supports(Type ValueType)
        {
            return ValueType == typeof(PhysicalQuantity) ? Grade.Ok : Grade.NotAtAll;
        }
 
        public override int CompareTo(object obj)
        {
            if (obj is QuantityLiteral Typed)
                return this.value.CompareTo(Typed.value);
 
            return base.CompareTo(obj);
        }
    }
}