SetDefinition.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Model;
using Waher.Script.Objects.Sets;
 
namespace Waher.Script.Operators.Sets
{
    public class SetDefinition : ElementList
    {
        public SetDefinition(ScriptNode[] Elements, int Start, int Length, Expression Expression)
            : base(Elements, Start, Length, Expression)
        {
        }
 
        public override IElement Evaluate(Variables Variables)
        {
            LinkedList<IElement> Elements = new LinkedList<IElement>();
 
            foreach (ScriptNode N in this.Elements)
                Elements.AddLast(N.Evaluate(Variables));
 
            return Encapsulate(Elements);
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            if (!this.isAsync)
                return this.Evaluate(Variables);
 
            LinkedList<IElement> Elements = new LinkedList<IElement>();
 
            foreach (ScriptNode N in this.Elements)
                Elements.AddLast(await N.EvaluateAsync(Variables));
 
            return Encapsulate(Elements);
        }
        public static IElement Encapsulate(ICollection<IElement> Elements)
        {
            return new FiniteSet(Elements);
        }
 
        public override PatternMatchResult PatternMatch(IElement CheckAgainst, Dictionary<string, IElement> AlreadyFound)
        {
            ScriptNode[] Elements = this.Elements;
 
            int? Size;
 
            if (!(CheckAgainst is ISet Set))
                return PatternMatchResult.NoMatch;
 
            if (!(Size = Set.Size).HasValue)
                return PatternMatchResult.Unknown;
 
            if (Size.Value != Elements.Length)
                return PatternMatchResult.NoMatch;
 
            PatternMatchResult Result;
            int i = 0;
 
            foreach (IElement E in Set.ChildElements)
            {
                Result = Elements[i++].PatternMatch(E, AlreadyFound);
                if (Result != PatternMatchResult.Match)
                    return Result;
            }
 
            return PatternMatchResult.Match;
        }
 
    }
}