SemanticLiteral.cs

using System;
using System.Text;
using Waher.Content.Semantic.Model.Literals;
using Waher.Runtime.Inventory;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
 
namespace Waher.Content.Semantic.Model
{
    public abstract class SemanticLiteral : SemanticElement, ISemanticLiteral
    {
        private object value;
        private Type valueType;
        private IComparable comparable;
 
        public SemanticLiteral()
        {
        }
 
        public SemanticLiteral(object Value, string StringValue)
        {
            this.value = Value;
            this.valueType = null;
            this.comparable = null;
 
            this.StringValue = StringValue;
        }
 
        public override bool IsLiteral => true;
 
        public object Value
        {
            get => this.value;
            set
            {
                this.value = value;
                this.valueType = null;
                this.comparable = null;
            }
        }
 
        public override object AssociatedObjectValue => this.value;
 
        public abstract string StringType { get; }
 
        public string StringValue { get; set; }
 
        public virtual IRing AssociatedRing => SemanticLiterals.Instance;
 
        public virtual IAbelianGroup AssociatedAbelianGroup => SemanticLiterals.Instance;
 
        public virtual IAbelianGroupElement Zero => SemanticLiterals.Instance.Zero;
 
        public virtual IGroup AssociatedGroup => SemanticLiterals.Instance;
 
        public virtual ISemiGroup AssociatedSemiGroup => SemanticLiterals.Instance;
 
        public virtual Grade Supports(string DataType)
        {
            return DataType == this.StringType ? Grade.Ok : Grade.NotAtAll;
        }
 
        public abstract Grade Supports(Type ValueType);
 
        public abstract ISemanticLiteral Parse(string Value, string DataType, string Language);
        
        public abstract ISemanticLiteral Encapsulate(object Value);
 
        public override string ToString()
        {
            return CustomLiteral.ToString(this.StringValue, null, this.StringType);
        }
 
        public override int CompareTo(object obj)
        {
            if (obj is SemanticLiteral Typed)
            {
                if (this.valueType is null)
                {
                    this.valueType = this.value?.GetType() ?? typeof(object);
                    this.comparable = this.value as IComparable;
                }
 
                if (Typed.valueType is null)
                {
                    Typed.valueType = Typed.value?.GetType() ?? typeof(object);
                    Typed.comparable = Typed.value as IComparable;
                }
 
                if (this.valueType == Typed.valueType && !(this.comparable is null))
                    return this.comparable.CompareTo(Typed.value);
            }
                
            return base.CompareTo(obj);
        }
 
        public virtual IRingElement MultiplyLeft(IRingElement Element)
        {
            return null;
        }
 
        public virtual IRingElement MultiplyRight(IRingElement Element)
        {
            return null;
        }
 
        public virtual IRingElement Invert()
        {
            return null;
        }
 
        public virtual IAbelianGroupElement Add(IAbelianGroupElement Element)
        {
            if (this.AddRight(Element) is IAbelianGroupElement Result)
                return Result;
 
            if (Element.AddLeft(this) is IAbelianGroupElement Result2)
                return Result2;
 
            return null;
        }
 
        public virtual IGroupElement Negate()
        {
            return null;
        }
 
        public virtual ISemiGroupElement AddLeft(ISemiGroupElement Element)
        {
            return null;
        }
 
        public virtual ISemiGroupElement AddRight(ISemiGroupElement Element)
        {
            return null;
        }
    }
}