ObjectExNihilo.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Runtime.Collections;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Operators.Vectors;
 
namespace Waher.Script.Operators
{
    public class ObjectExNihilo : ScriptNode
    {
        private readonly ChunkedList<KeyValuePair<string, ScriptNode>> members;
        private readonly bool hasWildcards = false;
        private Dictionary<string, ScriptNode> quick = null;
        private bool isAsync;
 
        public ObjectExNihilo(ChunkedList<KeyValuePair<string, ScriptNode>> Members, int Start, int Length, Expression Expression)
            : this(Members, false, Start,Length, Expression)
        {
        }
 
        public ObjectExNihilo(ChunkedList<KeyValuePair<string, ScriptNode>> Members, 
            bool HasWildcards, int Start, int Length, Expression Expression)
            : base(Start, Length, Expression)
        {
            this.members = Members;
            this.hasWildcards = HasWildcards;
 
            foreach (KeyValuePair<string, ScriptNode> P in Members)
                P.Value?.SetParent(this);
 
            this.CalcIsAsync();
        }
 
        public bool HasWildcards => this.hasWildcards;
 
        private void CalcIsAsync()
        {
            this.isAsync = false;
 
            foreach (KeyValuePair<string, ScriptNode> P in this.members)
            {
                if (P.Value?.IsAsynchronous ?? false)
                {
                    this.isAsync = true;
                    break;
                }
            }
        }
 
        public ChunkedList<KeyValuePair<string, ScriptNode>> Members => this.members;
 
        public override bool IsAsynchronous => this.isAsync;
 
        public override IElement Evaluate(Variables Variables)
        {
            Dictionary<string, IElement> Result = new Dictionary<string, IElement>();
 
            foreach (KeyValuePair<string, ScriptNode> P in this.members)
                Result[P.Key] = P.Value.Evaluate(Variables);
 
            return new ObjectValue(Result);
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            if (!this.isAsync)
                return this.Evaluate(Variables);
 
            Dictionary<string, IElement> Result = new Dictionary<string, IElement>();
 
            foreach (KeyValuePair<string, ScriptNode> P in this.members)
                Result[P.Key] = await P.Value.EvaluateAsync(Variables);
 
            return new ObjectValue(Result);
        }
 
        public override bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            ChunkNode<KeyValuePair<string, ScriptNode>> Loop;
            int i, c;
 
            if (Order == SearchMethod.DepthFirst)
            {
                Loop = this.members?.FirstChunk;
 
                while (!(Loop is null))
                {
                    for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                    {
                        if (!(Loop[i].Value?.ForAllChildNodes(Callback, State, Order) ?? false))
                            return false;
                    }
 
                    Loop = Loop.Next;
                }
            }
 
            bool RecalcIsAsync = false;
 
            if (!this.members.Update((ref KeyValuePair<string, ScriptNode> P, out bool Keep) =>
            {
                Keep = true;
 
                ScriptNode Node = P.Value;
                if (!(Node is null))
                {
                    bool Result = Callback(Node, out ScriptNode NewNode, State);
                    if (!(NewNode is null))
                    {
                        P = new KeyValuePair<string, ScriptNode>(P.Key, NewNode);
                        NewNode.SetParent(this);
                        Node = NewNode;
 
                        RecalcIsAsync = true;
                    }
 
                    if (!Result || (Order == SearchMethod.TreeOrder && !Node.ForAllChildNodes(Callback, State, Order)))
                    {
                        if (RecalcIsAsync)
                            this.CalcIsAsync();
 
                        return false;
                    }
                }
 
                return true;
            }))
            {
                return false;
            }
 
            if (RecalcIsAsync)
                this.CalcIsAsync();
 
            if (Order == SearchMethod.BreadthFirst)
            {
                Loop = this.members?.FirstChunk;
 
                while (!(Loop is null))
                {
                    for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                    {
                        if (!(Loop[i].Value?.ForAllChildNodes(Callback, State, Order) ?? false))
                            return false;
                    }
 
                    Loop = Loop.Next;
                }
            }
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is ObjectExNihilo O) ||
                this.hasWildcards != O.hasWildcards ||
                !base.Equals(obj))
            {
                return false;
            }
 
            IEnumerator<KeyValuePair<string, ScriptNode>> e1 = this.members.GetEnumerator();
            IEnumerator<KeyValuePair<string, ScriptNode>> e2 = O.members.GetEnumerator();
 
            try
            {
                while (true)
                {
                    bool b1 = e1.MoveNext();
                    bool b2 = e2.MoveNext();
 
                    if (b1 ^ b2)
                        return false;
 
                    if (!b1)
                        return true;
 
                    KeyValuePair<string, ScriptNode> Item1 = e1.Current;
                    KeyValuePair<string, ScriptNode> Item2 = e2.Current;
 
                    if (!Item1.Key.Equals(Item2.Key) ||
                        !Item1.Value.Equals(Item2.Value))
                    {
                        return false;
                    }
                }
            }
            finally
            {
                e1.Dispose();
                e2.Dispose();
            }
        }
 
        public override int GetHashCode()
        {
            int Result = base.GetHashCode();
 
            Result ^= Result << 5 ^ this.hasWildcards.GetHashCode();
 
            foreach (KeyValuePair<string, ScriptNode> P in this.members)
            {
                Result ^= Result << 5 ^ P.Key.GetHashCode();
                Result ^= Result << 5 ^ P.Value.GetHashCode();
            }
 
            return Result;
        }
 
        public override PatternMatchResult PatternMatch(IElement CheckAgainst, Dictionary<string, IElement> AlreadyFound)
        {
            PatternMatchResult Result;
 
            if (CheckAgainst.AssociatedObjectValue is IDictionary<string, IElement> Object)
            {
                this.CheckQuick();
 
                if (!this.hasWildcards)
                {
                    foreach (KeyValuePair<string, IElement> P in Object)
                    {
                        if (!this.quick.ContainsKey(P.Key))
                            return PatternMatchResult.NoMatch;
                    }
                }
 
                foreach (KeyValuePair<string, ScriptNode> P in this.members)
                {
                    if (Object.TryGetValue(P.Key, out IElement E))
                        Result = P.Value.PatternMatch(E, AlreadyFound);
                    else
                        Result = P.Value.PatternMatch(ObjectValue.Null, AlreadyFound);
 
                    if (Result != PatternMatchResult.Match)
                        return Result;
                }
            }
            else if (CheckAgainst.AssociatedObjectValue is IDictionary<string, object> Object2)
            {
                this.CheckQuick();
 
                if (!this.hasWildcards)
                {
                    foreach (KeyValuePair<string, object> P in Object2)
                    {
                        if (!this.quick.ContainsKey(P.Key))
                            return PatternMatchResult.NoMatch;
                    }
                }
 
                foreach (KeyValuePair<string, ScriptNode> P in this.members)
                {
                    if (Object2.TryGetValue(P.Key, out object E))
                    {
                        if (E is Array A)
                            Result = P.Value.PatternMatch(VectorDefinition.Encapsulate(A, false, this), AlreadyFound);
                        else
                            Result = P.Value.PatternMatch(Expression.Encapsulate(E), AlreadyFound);
                    }
                    else
                        Result = P.Value.PatternMatch(ObjectValue.Null, AlreadyFound);
 
                    if (Result != PatternMatchResult.Match)
                        return Result;
                }
            }
            else if (CheckAgainst.AssociatedObjectValue is IDictionary<string, string> Object3)
            {
                this.CheckQuick();
 
                if (!this.hasWildcards)
                {
                    foreach (KeyValuePair<string, string> P in Object3)
                    {
                        if (!this.quick.ContainsKey(P.Key))
                            return PatternMatchResult.NoMatch;
                    }
                }
 
                foreach (KeyValuePair<string, ScriptNode> P in this.members)
                {
                    if (Object3.TryGetValue(P.Key, out string s))
                        Result = P.Value.PatternMatch(new StringValue(s), AlreadyFound);
                    else
                        Result = P.Value.PatternMatch(ObjectValue.Null, AlreadyFound);
 
                    if (Result != PatternMatchResult.Match)
                        return Result;
                }
            }
            else
                return PatternMatchResult.NoMatch;
 
            return PatternMatchResult.Match;
        }
 
        private void CheckQuick()
        {
            if (this.quick is null)
            {
                Dictionary<string, ScriptNode> Quick = new Dictionary<string, ScriptNode>();
 
                foreach (KeyValuePair<string, ScriptNode> N in this.members)
                    Quick[N.Key] = N.Value;
 
                this.quick = Quick;
            }
        }
 
    }
}