BinaryVectorOperator.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;
 
namespace Waher.Script.Model
{
    public abstract class BinaryVectorOperator : BinaryOperator
    {
        public BinaryVectorOperator(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, Variables);
        }
 
        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 await this.EvaluateAsync(Left, Right, Variables);
        }
 
        public virtual IElement Evaluate(IElement Left, IElement Right, Variables Variables)
        {
            if (Left is IVector VL)
            {
                if (Right is IVector VR)
                {
                    ISet LeftSet = Left.AssociatedSet;
                    ISet RightSet = Right.AssociatedSet;
                    UpgradeBehaviour UpgradeBehaviour;
 
                    if (!LeftSet.Equals(RightSet) && (UpgradeBehaviour = this.ScalarUpgradeBehaviour) != UpgradeBehaviour.DifferentTypesOk)
                    {
                        if (!Expression.UpgradeField(ref Left, ref LeftSet, ref Right, ref RightSet))
                        {
                            if (UpgradeBehaviour == UpgradeBehaviour.SameTypeRequired)
                                throw new ScriptRuntimeException("Incompatible operands.", this);
                        }
                    }
 
                    return this.EvaluateVector(VL, VR, Variables);
                }
                else
                {
                    LinkedList<IElement> Result = new LinkedList<IElement>();
 
                    foreach (IElement RightChild in Right.ChildElements)
                        Result.AddLast(this.Evaluate(Left, RightChild, Variables));
 
                    return Right.Encapsulate(Result, this);
                }
            }
            else
            {
                if (Right is IVector)
                {
                    LinkedList<IElement> Result = new LinkedList<IElement>();
 
                    foreach (IElement LeftChild in Left.ChildElements)
                        Result.AddLast(this.Evaluate(LeftChild, Right, Variables));
 
                    return Left.Encapsulate(Result, this);
                }
                else
                {
                    ICollection<IElement> LeftChildren = Left.ChildElements;
                    ICollection<IElement> RightChildren = Right.ChildElements;
 
                    if (LeftChildren.Count == RightChildren.Count)
                    {
                        LinkedList<IElement> Result = new LinkedList<IElement>();
                        IEnumerator<IElement> eLeft = LeftChildren.GetEnumerator();
                        IEnumerator<IElement> eRight = RightChildren.GetEnumerator();
 
                        try
                        {
                            while (eLeft.MoveNext() && eRight.MoveNext())
                                Result.AddLast(this.Evaluate(eLeft.Current, eRight.Current, Variables));
                        }
                        finally
                        {
                            eLeft.Dispose();
                            eRight.Dispose();
                        }
 
                        return Left.Encapsulate(Result, 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, Variables));
 
                            LeftResult.AddLast(Right.Encapsulate(RightResult, this));
                        }
 
                        return Left.Encapsulate(LeftResult, this);
                    }
                }
            }
        }
 
        public virtual async Task<IElement> EvaluateAsync(IElement Left, IElement Right, Variables Variables)
        {
            if (Left is IVector VL)
            {
                if (Right is IVector VR)
                {
                    ISet LeftSet = Left.AssociatedSet;
                    ISet RightSet = Right.AssociatedSet;
                    UpgradeBehaviour UpgradeBehaviour;
 
                    if (!LeftSet.Equals(RightSet) && (UpgradeBehaviour = this.ScalarUpgradeBehaviour) != UpgradeBehaviour.DifferentTypesOk)
                    {
                        if (!Expression.UpgradeField(ref Left, ref LeftSet, ref Right, ref RightSet))
                        {
                            if (UpgradeBehaviour == UpgradeBehaviour.SameTypeRequired)
                                throw new ScriptRuntimeException("Incompatible operands.", this);
                        }
                    }
 
                    return await this.EvaluateVectorAsync(VL, VR, Variables);
                }
                else
                {
                    LinkedList<IElement> Result = new LinkedList<IElement>();
 
                    foreach (IElement RightChild in Right.ChildElements)
                        Result.AddLast(await this.EvaluateAsync(Left, RightChild, Variables));
 
                    return Right.Encapsulate(Result, this);
                }
            }
            else
            {
                if (Right is IVector)
                {
                    LinkedList<IElement> Result = new LinkedList<IElement>();
 
                    foreach (IElement LeftChild in Left.ChildElements)
                        Result.AddLast(await this.EvaluateAsync(LeftChild, Right, Variables));
 
                    return Left.Encapsulate(Result, this);
                }
                else
                {
                    ICollection<IElement> LeftChildren = Left.ChildElements;
                    ICollection<IElement> RightChildren = Right.ChildElements;
 
                    if (LeftChildren.Count == RightChildren.Count)
                    {
                        LinkedList<IElement> Result = new LinkedList<IElement>();
                        IEnumerator<IElement> eLeft = LeftChildren.GetEnumerator();
                        IEnumerator<IElement> eRight = RightChildren.GetEnumerator();
 
                        try
                        {
                            while (eLeft.MoveNext() && eRight.MoveNext())
                                Result.AddLast(await this.EvaluateAsync(eLeft.Current, eRight.Current, Variables));
                        }
                        finally
                        {
                            eLeft.Dispose();
                            eRight.Dispose();
                        }
 
                        return Left.Encapsulate(Result, 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(await this.EvaluateAsync(LeftChild, RightChild, Variables));
 
                            LeftResult.AddLast(Right.Encapsulate(RightResult, this));
                        }
 
                        return Left.Encapsulate(LeftResult, this);
                    }
                }
            }
        }
 
        public abstract IElement EvaluateVector(IVector Left, IVector Right, Variables Variables);
 
        public virtual Task<IElement> EvaluateVectorAsync(IVector Left, IVector Right, Variables Variables)
        {
            return Task.FromResult<IElement>(this.EvaluateVector(Left, Right, Variables));
        }
 
        public virtual UpgradeBehaviour ScalarUpgradeBehaviour => UpgradeBehaviour.SameTypeRequired;
    }
}