IntersectionSet.cs

using System;
using System.Collections.Generic;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
 
namespace Waher.Script.Objects.Sets
{
    public sealed class IntersectionSet : Set
    {
        private readonly ISet set1;
        private readonly ISet set2;
 
        public IntersectionSet(ISet Set1, ISet Set2)
        {
            this.set1 = Set1;
            this.set2 = Set2;
        }
 
        public override bool Contains(IElement Element)
        {
            return this.set1.Contains(Element) && this.set2.Contains(Element);
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is IntersectionSet S))
                return false;
 
            return (this.set1.Equals(S.set1) && this.set2.Equals(S.set2));
 
            // TODO: This is not mathematically correct. For the time being, it serves the purpose of allowing the object to be included in dictionaries, etc.
        }
 
        public override int GetHashCode()
        {
            return this.set1.GetHashCode() ^ this.set2.GetHashCode();
        }
 
        public override ICollection<IElement> ChildElements
        {
            get
            {
                if (!(this.elements is null))
                    return this.elements.Keys;
 
                ICollection<IElement> E1 = this.set1.ChildElements;
                if (E1 is null)
                    return null;
 
                ICollection<IElement> E2 = this.set2.ChildElements;
                if (E2 is null)
                    return null;
 
                Dictionary<IElement, bool> Elements = new Dictionary<IElement, bool>();
 
                foreach (IElement E in E1)
                    Elements[E] = true;
 
                Dictionary<IElement, bool> Elements2 = new Dictionary<IElement, bool>();
 
                foreach (IElement E in E2)
                {
                    if (Elements.ContainsKey(E))
                        Elements2[E] = true;
                }
 
                this.elements = Elements2;
                return Elements2.Keys;
            }
        }
 
        private Dictionary<IElement, bool> elements = null;
 
        public override string ToString()
        {
            return this.set1.ToString() + "∩" + this.set2.ToString();
        }
 
        public override object AssociatedObjectValue
        {
            get
            {
                ICollection<IElement> Elements = this.ChildElements;
                if (Elements is null)
                    return this;
 
                object[] Elements2 = new object[Elements.Count];
                int i = 0;
 
                foreach (IElement E in Elements)
                    Elements2[i++] = E.AssociatedObjectValue;
 
                return Elements2;
            }
        }
 
        public override int? Size
        {
            get
            {
                ICollection<IElement> ChildElements = this.ChildElements;
                if (ChildElements is null)
                    return null;
                else
                    return ChildElements.Count;
            }
        }
    }
}