SemanticTriple.cs

using System;
using System.Collections.Generic;
using System.Text;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Model;
 
namespace Waher.Content.Semantic.Model
{
    public class SemanticTriple : ISemanticTriple, ISemanticElement
    {
        public SemanticTriple()
            : this(null, null, null)
        {
        }
 
        public SemanticTriple(ISemanticElement Subject, ISemanticElement Predicate, ISemanticElement Object)
        {
            this.Subject = Subject;
            this.Predicate = Predicate;
            this.Object = Object;
        }
 
        public ISemanticElement Subject { get; set; }
 
        public ISemanticElement Predicate { get; set; }
 
        public ISemanticElement Object { get; set; }
 
        public object Tag { get; set; }
 
        public bool IsLiteral => this.Subject.IsLiteral && this.Predicate.IsLiteral && this.Object.IsLiteral;
 
        public ISet AssociatedSet => SemanticElements.Instance;
 
        public object AssociatedObjectValue => this;
 
        public object ElementValue => this;
 
        public bool IsScalar => false;
 
        public IElement Encapsulate(ICollection<IElement> Elements, ScriptNode Node)
        {
            if (Elements.Count != 3)
                return null;
 
            ISemanticElement Subject = null;
            ISemanticElement Predicate = null;
            ISemanticElement Object = null;
 
            foreach (IElement E in Elements)
            {
                if (!(E is ISemanticElement SemanticElement))
                    SemanticElement = SemanticElements.Encapsulate(E.AssociatedObjectValue);
 
                if (Subject is null)
                    Subject = SemanticElement;
                else if (Predicate is null)
                    Predicate = SemanticElement;
                else
                    Object = SemanticElement;
            }
 
            return new SemanticTriple(Subject, Predicate, Object);
        }
 
        public virtual bool TryConvertTo(Type DesiredType, out object Value)
        {
            Value = null;
            return false;
        }
 
        public ICollection<IElement> ChildElements
        {
            get
            {
                return new IElement[]
                {
                    this.Subject,
                    this.Predicate,
                    this.Object
                };
            }
        }
 
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append("<< ");
            sb.Append(this.Subject);
            sb.Append('\t');
            sb.Append(this.Predicate);
            sb.Append('\t');
            sb.Append(this.Object);
            sb.Append(" >>");
 
            return sb.ToString();
        }
 
        public override bool Equals(object obj)
        {
            return obj is SemanticTriple Typed &&
                Typed.Subject.Equals(this.Subject) &&
                Typed.Predicate.Equals(this.Predicate) &&
                Typed.Object.Equals(this.Object);
        }
 
        public override int GetHashCode()
        {
            int Result = this.Subject.GetHashCode();
            Result ^= Result << 5 ^ this.Predicate.GetHashCode();
            Result ^= Result << 5 ^ this.Object.GetHashCode();
 
            return Result;
        }
 
        public int CompareTo(object obj)
        {
            if (!(obj is SemanticTriple T))
                return this.ToString().CompareTo(obj?.ToString() ?? string.Empty);
 
            int i = this.Subject.CompareTo(T.Subject);
            if (i != 0)
                return i;
 
            i = this.Predicate.CompareTo(T.Predicate);
            if (i != 0)
                return i;
 
            return this.Object.CompareTo(T.Object);
        }
 
        public ISemanticElement this[int Index]
        {
            get
            {
                switch (Index)
                {
                    case 0: return this.Subject;
                    case 1: return this.Predicate;
                    case 2: return this.Object;
                    default: return null;
                }
            }
        }
    }
}