FiniteSet.cs

using System.Collections;
using System.Collections.Generic;
using System.Text;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
 
namespace Waher.Script.Objects.Sets
{
    public sealed class FiniteSet : Set
    {
        private readonly Dictionary<IElement, bool> elements;
 
        public FiniteSet(IEnumerable<IElement> Elements)
        {
            this.elements = new Dictionary<IElement, bool>();
            foreach (IElement E in Elements)
                this.elements[E] = true;
        }
 
        public FiniteSet(IEnumerable Elements)
        {
            this.elements = new Dictionary<IElement, bool>();
            
            foreach (object Item in Elements)
            {
                IElement E = Expression.Encapsulate(Item);
                this.elements[E] = true;
            }
        }
 
        public override bool Contains(IElement Element)
        {
            return this.elements.ContainsKey(Element);
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is FiniteSet S))
                return false;
 
            if (this.elements.Count != S.elements.Count)
                return false;
 
            foreach (IElement E in this.elements.Keys)
            {
                if (!S.elements.ContainsKey(E))
                    return false;
            }
 
            return true;
        }
 
        public override int GetHashCode()
        {
            int i = 0;
 
            foreach (IElement E in this.elements.Keys)
                i ^= i << 5 ^ E.GetHashCode();
 
            return i;
        }
 
        public override ICollection<IElement> ChildElements => this.elements.Keys;
 
        public override string ToString()
        {
            StringBuilder sb = null;
 
            foreach (IElement Element in this.elements.Keys)
            {
                if (sb is null)
                    sb = new StringBuilder("{");
                else
                    sb.Append(", ");
 
                sb.Append(Element.ToString());
            }
 
            if (sb is null)
                return "{}";
            else
            {
                sb.Append('}');
                return sb.ToString();
            }
        }
 
        public override object AssociatedObjectValue
        {
            get
            {
                object[] Elements = new object[this.elements.Count];
                int i = 0;
 
                foreach (IElement E in this.elements.Keys)
                    Elements[i++] = E.AssociatedObjectValue;
 
                return Elements;
            }
        }
 
        public override int? Size
        {
            get { return this.elements.Count; }
        }
 
    }
}