SemanticElementVector.cs

using System;
using System.Collections.Generic;
using Waher.Runtime.Collections;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Model;
 
namespace Waher.Content.Semantic.Model
{
    public class SemanticElementVector : ISemanticElement, IVector
    {
        private readonly ChunkedList<IElement> elements = new ChunkedList<IElement>();
 
        public SemanticElementVector()
        {
        }
 
        public void Add(ISemanticElement Element)
        {
            this.elements.Add(Element);
        }
 
        public object Tag { get; set; }
 
        public bool IsLiteral => false;
 
        public ISet AssociatedSet => SemanticElements.Instance;
 
        public object AssociatedObjectValue => this.elements;
 
        public bool IsScalar => false;
 
        public ICollection<IElement> ChildElements => this.elements;
 
        public IElement Encapsulate(ChunkedList<IElement> Elements, ScriptNode Node)
        {
            SemanticElementVector Result = new SemanticElementVector();
            Result.elements.AddRange(Elements);
            return Result;
        }
 
        public IElement Encapsulate(ICollection<IElement> Elements, ScriptNode Node)
        {
            SemanticElementVector Result = new SemanticElementVector();
            Result.elements.AddRange(Elements);
            return Result;
        }
 
        public virtual bool TryConvertTo(Type DesiredType, out object Value)
        {
            Value = null;
            return false;
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is SemanticElementVector Typed) ||
                this.elements.Count != Typed.elements.Count)
            {
                return false;
            }
 
            IEnumerator<IElement> e1 = null;
            IEnumerator<IElement> e2 = null;
 
            try
            {
                e1 = this.elements.GetEnumerator();
                e2 = Typed.elements.GetEnumerator();
 
                while (e1.MoveNext() && e2.MoveNext())
                {
                    if (!e1.Current.Equals(e2.Current))
                        return false;
                }
            }
            finally
            {
                e1?.Dispose();
                e2?.Dispose();
            }
 
            return true;
        }
 
        public override int GetHashCode()
        {
            int Result = this.elements.Count.GetHashCode();
 
            foreach (IElement Element in this.elements)
                Result ^= Result << 5 ^ Element.GetHashCode();
 
            return Result;
        }
 
        public override string ToString()
        {
            return Expression.ToExpressionString(this.elements);
        }
 
        public virtual int CompareTo(object obj)
        {
            return this.ToString().CompareTo(obj?.ToString() ?? string.Empty);
        }
 
        public int Dimension => this.elements.Count;
 
        public ICollection<IElement> VectorElements => this.elements;
 
        public IElement GetElement(int Index) => this.elements[Index];
 
        public void SetElement(int Index, IElement Value)
        {
            this.elements[Index] = Value;
        }
    }
}