In.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Operators.Membership
{
    public class In : BinaryOperator
    {
        public In(ScriptNode Left, ScriptNode Right, int Start, int Length, Expression Expression)
            : base(Left, Right, Start, Length, Expression)
        {
        }
 
        public override IElement Evaluate(Variables Variables)
        {
            IElement Left = this.left.Evaluate(Variables);
            IElement Right = this.right.Evaluate(Variables);
 
            return this.Evaluate(Left, Right);
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            if (!this.isAsync)
                return this.Evaluate(Variables);
 
            IElement Left = await this.left.EvaluateAsync(Variables);
            IElement Right = await this.right.EvaluateAsync(Variables);
 
            return this.Evaluate(Left, Right);
        }
        public virtual IElement Evaluate(IElement Left, IElement Right)
        {
            if (Right is ISet Set)
                return this.Evaluate(Left, Set);
            else if (Right is IVector Vector)
                return this.Evaluate(Left, Vector);
            else if (Right.IsScalar)
                throw new ScriptRuntimeException("Right operand in an IN operation must be a set.", this);
            else
            {
                if (Left.IsScalar)
                {
                    LinkedList<IElement> Elements = new LinkedList<IElement>();
 
                    foreach (IElement E in Right.ChildElements)
                        Elements.AddLast(this.Evaluate(Left, E));
 
                    return Right.Encapsulate(Elements, this);
                }
                else
                {
                    ICollection<IElement> LeftChildren = Left.ChildElements;
                    ICollection<IElement> RightChildren = Right.ChildElements;
 
                    if (LeftChildren.Count == RightChildren.Count)
                    {
                        LinkedList<IElement> Elements = new LinkedList<IElement>();
                        IEnumerator<IElement> eLeft = LeftChildren.GetEnumerator();
                        IEnumerator<IElement> eRight = RightChildren.GetEnumerator();
 
                        try
                        {
                            while (eLeft.MoveNext() && eRight.MoveNext())
                                Elements.AddLast(this.Evaluate(eLeft.Current, eRight.Current));
                        }
                        finally
                        {
                            eLeft.Dispose();
                            eRight.Dispose();
                        }
 
                        return Left.Encapsulate(Elements, this);
                    }
                    else
                    {
                        LinkedList<IElement> LeftResult = new LinkedList<IElement>();
 
                        foreach (IElement LeftChild in LeftChildren)
                        {
                            LinkedList<IElement> RightResult = new LinkedList<IElement>();
 
                            foreach (IElement RightChild in RightChildren)
                                RightResult.AddLast(this.Evaluate(LeftChild, RightChild));
 
                            LeftResult.AddLast(Right.Encapsulate(RightResult, this));
                        }
 
                        return Left.Encapsulate(LeftResult, this);
                    }
                }
            }
        }
 
        public virtual IElement Evaluate(IElement Left, ISet Right)
        {
            if (Right.Contains(Left))
                return BooleanValue.True;
            else
                return BooleanValue.False;
        }
 
        public virtual IElement Evaluate(IElement Left, IVector Right)
        {
            foreach (IElement Element in Right.ChildElements)
            {
                if (Left.Equals(Element))
                    return BooleanValue.True;
            }
 
            return BooleanValue.False;
        }
 
    }
}