SemanticElements.cs

using System.Collections.Generic;
using System;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
using Waher.Runtime.Inventory;
using Waher.Content.Semantic.Model.Literals;
 
namespace Waher.Content.Semantic.Model
{
    public class SemanticElements : Set, IOrderedSet
    {
        private static readonly Dictionary<Type, ISemanticLiteral> literalPerType = new Dictionary<Type, ISemanticLiteral>();
        private static readonly Dictionary<string, ISemanticLiteral> dataTypes = new Dictionary<string, ISemanticLiteral>();
 
        static SemanticElements()
        {
            Types.OnInvalidated += (Sender, e) =>
            {
                lock (literalPerType)
                {
                    literalPerType.Clear();
                }
 
                lock (dataTypes)
                {
                    dataTypes.Clear();
                }
            };
        }
 
        public static readonly SemanticElements Instance = new SemanticElements();
 
        public SemanticElements()
        {
        }
 
        public override bool Contains(IElement Element)
        {
            return Element is ISemanticElement;
        }
 
        public override int? Size => null;
 
        public static ISemanticElement Parse(string Value, string DataType, string Language)
        {
            ISemanticLiteral LiteralType;
 
            lock (dataTypes)
            {
                if (!dataTypes.TryGetValue(DataType, out LiteralType))
                {
                    LiteralType = Types.FindBest<ISemanticLiteral, string>(DataType)
                        ?? new CustomLiteral(string.Empty, DataType);
 
                    dataTypes[DataType] = LiteralType;
                }
            }
 
            return LiteralType.Parse(Value, DataType, Language);
        }
 
        public static ISemanticElement Encapsulate(object Value)
        {
            if (Value is ISemanticElement Element)
                return Element;
 
            if (Value is Uri Uri)
                return new UriNode(Uri, Uri.OriginalString);
 
            return EncapsulateLiteral(Value);
        }
 
        public static ISemanticLiteral EncapsulateLiteral(object Value)
        {
            if (Value is null)
                return new UndefinedLiteral();
 
            Type T = Value?.GetType() ?? typeof(object);
            ISemanticLiteral Literal;
 
            lock (literalPerType)
            {
                if (!literalPerType.TryGetValue(T, out Literal))
                {
                    Literal = Types.FindBest<ISemanticLiteral, Type>(T)
                        ?? new CustomLiteral(string.Empty, string.Empty);
 
                    literalPerType[T] = Literal;
                }
            }
 
            return Literal.Encapsulate(Value);
        }
 
        public override bool Equals(object obj)
        {
            return obj.GetType() == typeof(SemanticElements);
        }
 
        public override int GetHashCode()
        {
            return typeof(SemanticElements).GetHashCode();
        }
 
        public int Compare(IElement x, IElement y)
        {
            if (x is IComparable Left)
                return Left.CompareTo(y);
            else
                return 1;
        }
    }
}