SparqlRegularPattern.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content.Semantic;
using Waher.Runtime.Collections;
using Waher.Script.Model;
using Waher.Script.Persistence.SPARQL.Filters;
using Waher.Script.Persistence.SQL;
 
namespace Waher.Script.Persistence.SPARQL.Patterns
{
    public class SparqlRegularPattern : ISparqlPattern
    {
        private ChunkedList<SemanticQueryTriple> triples = null;
        private ChunkedList<KeyValuePair<ScriptNode, ScriptNode>> boundVariables = null;
        private ChunkedList<IFilterNode> filter = null;
 
        public SparqlRegularPattern()
        {
        }
 
        public bool IsEmpty => !(this.HasTriples || this.HasBoundVariables || this.HasFilter);
 
        public ChunkedList<SemanticQueryTriple> Triples => this.triples;
 
        public int TripleCount => this.triples?.Count ?? 0;
 
        public IEnumerable<KeyValuePair<ScriptNode, ScriptNode>> BoundVariables => this.boundVariables;
 
        public IEnumerable<IFilterNode> Filter => this.filter;
 
        public bool HasTriples => !(this.triples is null);
 
        public bool HasBoundVariables => !(this.boundVariables is null);
 
        public bool HasFilter => !(this.filter is null);
 
        public void AddTriple(SemanticQueryTriple Triple)
        {
            if (this.triples is null)
                this.triples = new ChunkedList<SemanticQueryTriple>();
            
            this.triples.Add(Triple);
        }
 
        public void AddVariableBinding(ScriptNode Value, ScriptNode Variable)
        {
            if (this.boundVariables is null)
                this.boundVariables = new ChunkedList<KeyValuePair<ScriptNode, ScriptNode>>();
 
            this.boundVariables.Add(new KeyValuePair<ScriptNode, ScriptNode>(Value, Variable));
        }
 
        public void AddFilter(ScriptNode Filter)
        {
            if (this.filter is null)
                this.filter = new ChunkedList<IFilterNode>();
 
            if (Filter is IFilterNode FilterNode)
                this.filter.Add(FilterNode);
            else
                this.filter.Add(new FilterScriptNode(Filter));
        }
 
        public Task<IEnumerable<Possibility>> Search(ISemanticCube Cube, Variables Variables,
            SparqlQuery Query)
        {
            return this.Search(Cube, Variables, null, Query);
        }
 
        public async Task<IEnumerable<Possibility>> Search(ISemanticCube Cube,
            Variables Variables, IEnumerable<Possibility> ExistingMatches,
            SparqlQuery Query)
        {
            if (this.HasTriples)
            {
                foreach (SemanticQueryTriple T in this.triples)
                {
                    switch (T.Type)
                    {
                        case QueryTripleType.Constant:
                            if (await Cube.GetTriplesBySubjectAndPredicateAndObject(T.Subject, T.Predicate, T.Object) is null)
                                return null;
                            break;
 
                        case QueryTripleType.SubjectVariable:
                            ExistingMatches = await this.CrossPossibilitiesOneVariable(ExistingMatches, T, 0, 1, 2, Cube);
                            break;
 
                        case QueryTripleType.PredicateVariable:
                            ExistingMatches = await this.CrossPossibilitiesOneVariable(ExistingMatches, T, 1, 0, 2, Cube);
                            break;
 
                        case QueryTripleType.ObjectVariable:
                            ExistingMatches = await this.CrossPossibilitiesOneVariable(ExistingMatches, T, 2, 0, 1, Cube);
                            break;
 
                        case QueryTripleType.SubjectPredicateVariables:
                            ExistingMatches = await this.CrossPossibilitiesTwoVariables(ExistingMatches, T, 0, 1, 2, Cube);
                            break;
 
                        case QueryTripleType.SubjectObjectVariable:
                            ExistingMatches = await this.CrossPossibilitiesTwoVariables(ExistingMatches, T, 0, 2, 1, Cube);
                            break;
 
                        case QueryTripleType.PredicateObjectVariable:
                            ExistingMatches = await this.CrossPossibilitiesTwoVariables(ExistingMatches, T, 1, 2, 0, Cube);
                            break;
 
                        case QueryTripleType.SubjectPredicateObjectVariable:
                            ExistingMatches = await this.CrossPossibilitiesThreeVariables(ExistingMatches, T, Cube);
                            break;
                    }
 
                    if (ExistingMatches is null)
                        return null;
 
                    using (IEnumerator<Possibility> e = ExistingMatches.GetEnumerator())
                    {
                        if (!e.MoveNext())
                            return null;
                    }
                }
            }
 
            if (this.HasBoundVariables && !(ExistingMatches is null))
            {
                ChunkedList<Possibility> NewMatches = new ChunkedList<Possibility>();
                ObjectProperties RecordVariables = null;
                Possibility P;
                string Name;
 
                foreach (Possibility Possibility in ExistingMatches)
                {
                    P = Possibility;
 
                    foreach (KeyValuePair<ScriptNode, ScriptNode> P2 in this.boundVariables)
                    {
                        if (RecordVariables is null)
                            RecordVariables = new ObjectProperties(P, Variables);
                        else
                            RecordVariables.Object = P;
 
                        if (P2.Value is VariableReference Ref)
                            Name = Ref.VariableName;
                        else
                        {
                            object Obj = await SparqlQuery.EvaluateValue(RecordVariables, P2.Value);
                            if (Obj is null)
                                continue;
 
                            Name = Obj.ToString();
                            if (string.IsNullOrEmpty(Name))
                                continue;
                        }
 
                        ISemanticElement Literal = await Query.EvaluateSemanticElement(RecordVariables, P2.Key);
                        if (!(Literal is null))
                            P = new Possibility(Name, Literal, P);
                    }
 
                    NewMatches.Add(P);
                }
 
                ExistingMatches = NewMatches;
            }
 
            if (this.HasFilter && !(ExistingMatches is null))
            {
                ChunkedList<Possibility> Filtered = null;
                ObjectProperties RecordVariables = null;
                bool Pass;
 
                foreach (Possibility P in ExistingMatches)
                {
                    if (RecordVariables is null)
                        RecordVariables = new ObjectProperties(P, Variables);
                    else
                        RecordVariables.Object = P;
 
                    Pass = true;
 
                    foreach (IFilterNode Filter in this.filter)
                    {
                        object Value = await SparqlQuery.EvaluateValue(RecordVariables, Filter, Cube, Query, P);
                        if (!(Value is bool b) || !b)
                        {
                            Pass = false;
                            break;
                        }
                    }
 
                    if (Pass)
                    {
                        if (Filtered is null)
                            Filtered = new ChunkedList<Possibility>();
 
                        Filtered.Add(P);
                    }
                }
 
                ExistingMatches = Filtered;
            }
 
            return ExistingMatches;
        }
 
        private async Task<IEnumerable<Possibility>> CrossPossibilitiesOneVariable(
            IEnumerable<Possibility> Possibilities, SemanticQueryTriple T, int VariableIndex,
            int ValueIndex1, int ValueIndex2, ISemanticCube Cube)
        {
            ChunkedList<Possibility> NewPossibilities = null;
            string Name = T.VariableName(VariableIndex);
            ISemanticElement Value;
 
            if (Possibilities is null)
            {
                IEnumerable<ISemanticTriple> NewTriples = await Cube.GetTriples(
                    T[ValueIndex1], ValueIndex1, T[ValueIndex2], ValueIndex2);
 
                if (NewTriples is null)
                    return null;
 
                NewPossibilities = new ChunkedList<Possibility>();
 
                foreach (ISemanticTriple T2 in NewTriples)
                    NewPossibilities.Add(new Possibility(Name, T2[VariableIndex]));
            }
            else
            {
                foreach (Possibility P in Possibilities)
                {
                    Value = P.GetValue(Name);
                    if (Value is null)
                    {
                        IEnumerable<ISemanticTriple> NewTriples = await Cube.GetTriples(
                            T[ValueIndex1], ValueIndex1, T[ValueIndex2], ValueIndex2);
 
                        if (NewTriples is null)
                            continue;
 
                        if (NewPossibilities is null)
                            NewPossibilities = new ChunkedList<Possibility>();
 
                        foreach (ISemanticTriple T2 in NewTriples)
                            NewPossibilities.Add(new Possibility(Name, T2[VariableIndex], P));
                    }
                    else
                    {
                        if (await Cube.GetTriplesBySubjectAndPredicateAndObject(Value, T.Predicate, T.Object) is null)
                            continue;
 
                        if (NewPossibilities is null)
                            NewPossibilities = new ChunkedList<Possibility>();
 
                        NewPossibilities.Add(P);
                    }
                }
            }
 
            return NewPossibilities;
        }
 
        private async Task<IEnumerable<Possibility>> CrossPossibilitiesTwoVariables(
            IEnumerable<Possibility> Possibilities, SemanticQueryTriple T, int VariableIndex1,
            int VariableIndex2, int ValueIndex, ISemanticCube Cube)
        {
            ChunkedList<Possibility> NewPossibilities = null;
            string Name = T.VariableName(VariableIndex1);
            string Name2 = T.VariableName(VariableIndex2);
            ISemanticElement Value;
            ISemanticElement Value2;
            bool SameName = Name == Name2;
 
            if (Possibilities is null)
            {
                IEnumerable<ISemanticTriple> Triples = await Cube.GetTriples(T[ValueIndex], ValueIndex);
                if (Triples is null)
                    return null;
 
                foreach (ISemanticTriple T2 in Triples)
                {
                    if (SameName)
                    {
                        ISemanticElement E = T2[VariableIndex1];
 
                        if (!E.Equals(T2[VariableIndex2]))
                            continue;
 
                        if (NewPossibilities is null)
                            NewPossibilities = new ChunkedList<Possibility>();
 
                        NewPossibilities.Add(new Possibility(Name, E));
                    }
                    else
                    {
                        if (NewPossibilities is null)
                            NewPossibilities = new ChunkedList<Possibility>();
 
                        NewPossibilities.Add(
                            new Possibility(Name, T2[VariableIndex1],
                            new Possibility(Name2, T2[VariableIndex2])));
                    }
                }
            }
            else
            {
                foreach (Possibility P in Possibilities)
                {
                    Value = P.GetValue(Name);
 
                    if (SameName)
                        Value2 = Value;
                    else
                        Value2 = P.GetValue(Name2);
 
                    bool IsProcessed = !(Value is null);
                    bool IsProcessed2 = !(Value2 is null);
 
                    if (IsProcessed && IsProcessed2)
                    {
                        if (await Cube.GetTriplesBySubjectAndPredicateAndObject(Value, Value2, T[ValueIndex]) is null)
                            continue;
 
                        if (NewPossibilities is null)
                            NewPossibilities = new ChunkedList<Possibility>();
 
                        NewPossibilities.Add(P);
                    }
                    else if (IsProcessed)
                    {
                        this.CrossPossibilities(
                            await Cube.GetTriples(Value, VariableIndex1, T[ValueIndex], ValueIndex),
                            P, Name2, VariableIndex2, ref NewPossibilities);
                    }
                    else if (IsProcessed2)
                    {
                        this.CrossPossibilities(
                            await Cube.GetTriples(Value2, VariableIndex2, T[ValueIndex], ValueIndex),
                            P, Name, VariableIndex1, ref NewPossibilities);
                    }
                    else
                    {
                        IEnumerable<ISemanticTriple> Triples = await Cube.GetTriples(T[ValueIndex], ValueIndex);
                        if (Triples is null)
                            return null;
 
                        foreach (ISemanticTriple T2 in Triples)
                        {
                            if (SameName)
                            {
                                ISemanticElement E = T2[VariableIndex1];
 
                                if (!E.Equals(T2[VariableIndex2]))
                                    continue;
 
                                if (NewPossibilities is null)
                                    NewPossibilities = new ChunkedList<Possibility>();
 
                                NewPossibilities.Add(new Possibility(Name, E, P));
                            }
                            else
                            {
                                if (NewPossibilities is null)
                                    NewPossibilities = new ChunkedList<Possibility>();
 
                                NewPossibilities.Add(
                                    new Possibility(Name, T2[VariableIndex1],
                                    new Possibility(Name2, T2[VariableIndex2], P)));
                            }
                        }
                    }
 
                }
            }
 
            return NewPossibilities;
        }
 
        private async Task<IEnumerable<Possibility>> CrossPossibilitiesThreeVariables(
            IEnumerable<Possibility> Possibilities, SemanticQueryTriple T, ISemanticCube Cube)
        {
            ChunkedList<Possibility> NewPossibilities = null;
            string Name = T.SubjectVariable;
            string Name2 = T.PredicateVariable;
            string Name3 = T.ObjectVariable;
            bool SameName = Name == Name2;
            bool SameName2 = Name == Name3;
            bool SameName3 = Name2 == Name3;
 
            if (Possibilities is null)
            {
                foreach (ISemanticTriple T2 in Cube)
                {
                    if (SameName && !T2.Subject.Equals(T2.Predicate))
                        continue;
 
                    if (SameName2 && !T2.Subject.Equals(T2.Object))
                        continue;
 
                    if (SameName3 && !T2.Predicate.Equals(T2.Object))
                        continue;
 
                    Possibility NewPossibility = new Possibility(Name, T2.Subject);
 
                    if (!SameName)
                        NewPossibility = new Possibility(Name2, T2.Predicate, NewPossibility);
 
                    if (!SameName2 && !SameName3)
                        NewPossibility = new Possibility(Name3, T2.Object, NewPossibility);
 
                    if (NewPossibilities is null)
                        NewPossibilities = new ChunkedList<Possibility>();
 
                    NewPossibilities.Add(NewPossibility);
                }
            }
            else
            {
                foreach (Possibility P in Possibilities)
                {
                    ISemanticElement Value = P.GetValue(Name);
                    ISemanticElement Value2 = SameName ? Value : P.GetValue(Name2);
                    ISemanticElement Value3 = SameName2 ? Value : SameName3 ? Value2 : P.GetValue(Name3);
                    bool IsProcessed = !(Value is null);
                    bool IsProcessed2 = !(Value2 is null);
                    bool IsProcessed3 = !(Value3 is null);
 
                    if (IsProcessed && IsProcessed2 && IsProcessed3)
                    {
                        if (await Cube.GetTriplesBySubjectAndPredicateAndObject(Value, Value2, Value3) is null)
                            continue;
 
                        if (NewPossibilities is null)
                            NewPossibilities = new ChunkedList<Possibility>();
 
                        NewPossibilities.Add(P);
                    }
                    else if (IsProcessed && IsProcessed2)   // Subject & Predicate variables already processed
                    {
                        this.CrossPossibilities(
                            await Cube.GetTriplesBySubjectAndPredicate(Value, Value2),
                            P, Name3, 2, ref NewPossibilities);
                    }
                    else if (IsProcessed && IsProcessed3)   // Subject & Object variables already processed
                    {
                        this.CrossPossibilities(
                            await Cube.GetTriplesBySubjectAndObject(Value, Value3),
                            P, Name2, 1, ref NewPossibilities);
                    }
                    else if (IsProcessed2 && IsProcessed3)  // Predicate & Object variables already processed
                    {
                        this.CrossPossibilities(
                            await Cube.GetTriplesByPredicateAndObject(Value2, Value3),
                            P, Name, 0, ref NewPossibilities);
                    }
                    else if (IsProcessed)                   // Subject variable processed
                    {
                        ISemanticPlane Plane = await Cube.GetTriplesBySubject(Value);
                        if (Plane is null)
                            continue;
 
                        foreach (ISemanticTriple T2 in Plane)
                        {
                            if (SameName3)
                            {
                                if (!T2.Predicate.Equals(T2.Object))
                                    continue;
 
                                if (NewPossibilities is null)
                                    NewPossibilities = new ChunkedList<Possibility>();
 
                                NewPossibilities.Add(new Possibility(Name2, T2.Predicate, P));
                            }
                            else
                            {
                                if (NewPossibilities is null)
                                    NewPossibilities = new ChunkedList<Possibility>();
 
                                NewPossibilities.Add(
                                    new Possibility(Name2, T2.Predicate,
                                    new Possibility(Name3, T2.Object, P)));
                            }
                        }
                    }
                    else if (IsProcessed2)                  // Predicate variable processed
                    {
                        ISemanticPlane Plane = await Cube.GetTriplesByPredicate(Value2);
                        if (Plane is null)
                            continue;
 
                        foreach (ISemanticTriple T2 in Plane)
                        {
                            if (SameName2)
                            {
                                if (!T2.Subject.Equals(T2.Object))
                                    continue;
 
                                if (NewPossibilities is null)
                                    NewPossibilities = new ChunkedList<Possibility>();
 
                                NewPossibilities.Add(new Possibility(Name, T2.Subject, P));
                            }
                            else
                            {
                                if (NewPossibilities is null)
                                    NewPossibilities = new ChunkedList<Possibility>();
 
                                NewPossibilities.Add(
                                    new Possibility(Name, T2.Subject,
                                    new Possibility(Name3, T2.Object, P)));
                            }
                        }
                    }
                    else if (IsProcessed3)                  // Object variable processed
                    {
                        ISemanticPlane Plane = await Cube.GetTriplesByObject(Value3);
                        if (Plane is null)
                            continue;
 
                        foreach (ISemanticTriple T2 in Plane)
                        {
                            if (SameName)
                            {
                                if (!T2.Subject.Equals(T2.Predicate))
                                    continue;
 
                                if (NewPossibilities is null)
                                    NewPossibilities = new ChunkedList<Possibility>();
 
                                NewPossibilities.Add(new Possibility(Name, T2.Subject, P));
                            }
                            else
                            {
                                if (NewPossibilities is null)
                                    NewPossibilities = new ChunkedList<Possibility>();
 
                                NewPossibilities.Add(
                                    new Possibility(Name, T2.Subject,
                                    new Possibility(Name2, T2.Predicate, P)));
                            }
                        }
                    }
                    else
                    {
                        foreach (ISemanticTriple T2 in Cube)
                        {
                            if (SameName && !T2.Subject.Equals(T2.Predicate))
                                continue;
 
                            if (SameName2 && !T2.Subject.Equals(T2.Object))
                                continue;
 
                            if (SameName3 && !T2.Predicate.Equals(T2.Object))
                                continue;
 
                            Possibility NewPossibility = new Possibility(Name, T2.Subject, P);
 
                            if (!SameName)
                                NewPossibility = new Possibility(Name2, T2.Predicate, NewPossibility);
 
                            if (!SameName2 && !SameName3)
                                NewPossibility = new Possibility(Name3, T2.Object, NewPossibility);
 
                            if (NewPossibilities is null)
                                NewPossibilities = new ChunkedList<Possibility>();
 
                            NewPossibilities.Add(NewPossibility);
                        }
                    }
                }
            }
 
            return NewPossibilities;
        }
 
        private void CrossPossibilities(IEnumerable<ISemanticTriple> NewTriples,
            Possibility Possibility, string Name, int Index, ref ChunkedList<Possibility> NewPossibilities)
        {
            if (NewTriples is null)
                return;
 
            if (NewPossibilities is null)
                NewPossibilities = new ChunkedList<Possibility>();
 
            foreach (ISemanticTriple T2 in NewTriples)
                NewPossibilities.Add(new Possibility(Name, T2[Index], Possibility));
        }
 
        public bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            if (Order == SearchMethod.DepthFirst)
            {
                if (!(this.triples is null))
                {
                    foreach (ISemanticTriple T in this.triples)
                    {
                        if (T.Subject is SemanticScriptElement S)
                        {
                            if (!S.Node.ForAllChildNodes(Callback, State, Order))
                                return false;
                        }
 
                        if (T.Predicate is SemanticScriptElement P)
                        {
                            if (!P.Node.ForAllChildNodes(Callback, State, Order))
                                return false;
                        }
 
                        if (T.Object is SemanticScriptElement O)
                        {
                            if (!O.Node.ForAllChildNodes(Callback, State, Order))
                                return false;
                        }
                    }
                }
 
                if (!(this.boundVariables is null))
                {
                    foreach (KeyValuePair<ScriptNode, ScriptNode> P in this.boundVariables)
                    {
                        if (!P.Key.ForAllChildNodes(Callback, State, Order))
                            return false;
 
                        if (!P.Value.ForAllChildNodes(Callback, State, Order))
                            return false;
                    }
                }
 
                if (!(this.filter is null))
                {
                    foreach (IFilterNode P in this.filter)
                    {
                        if (!P.ScriptNode.ForAllChildNodes(Callback, State, Order))
                            return false;
                    }
                }
            }
 
            this.ForAll(Callback, State, Order);
 
            if (Order == SearchMethod.BreadthFirst)
            {
                if (!(this.triples is null))
                {
                    foreach (ISemanticTriple T in this.triples)
                    {
                        if (T.Subject is SemanticScriptElement S)
                        {
                            if (!S.Node.ForAllChildNodes(Callback, State, Order))
                                return false;
                        }
 
                        if (T.Predicate is SemanticScriptElement P)
                        {
                            if (!P.Node.ForAllChildNodes(Callback, State, Order))
                                return false;
                        }
 
                        if (T.Object is SemanticScriptElement O)
                        {
                            if (!O.Node.ForAllChildNodes(Callback, State, Order))
                                return false;
                        }
                    }
                }
 
                if (!(this.boundVariables is null))
                {
                    foreach (KeyValuePair<ScriptNode, ScriptNode> P in this.boundVariables)
                    {
                        if (!P.Key.ForAllChildNodes(Callback, State, Order))
                            return false;
 
                        if (!P.Value.ForAllChildNodes(Callback, State, Order))
                            return false;
                    }
                }
 
                if (!(this.filter is null))
                {
                    foreach (IFilterNode P in this.filter)
                    {
                        if (!P.ScriptNode.ForAllChildNodes(Callback, State, Order))
                            return false;
                    }
                }
            }
 
            return true;
        }
 
        public bool ForAll(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            int i, c;
 
            if (!(this.triples is null))
            {
                ChunkNode<SemanticQueryTriple> Loop = this.triples.FirstChunk;
                SemanticQueryTriple T;
 
                while (!(Loop is null))
                {
                    for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                    {
                        T = Loop[i];
 
                        if (T.Subject is SemanticScriptElement S)
                        {
                            if (!S.ForAll(Callback, State, Order))
                                return false;
                        }
 
                        if (T.Predicate is SemanticScriptElement P)
                        {
                            if (!P.ForAll(Callback, State, Order))
                                return false;
                        }
 
                        if (T.Object is SemanticScriptElement O)
                        {
                            if (!O.ForAll(Callback, State, Order))
                                return false;
                        }
                    }
 
                    Loop = Loop.Next;
                }
            }
 
            if (!(this.boundVariables is null))
            {
                ChunkNode<KeyValuePair<ScriptNode, ScriptNode>> Loop = this.boundVariables.FirstChunk;
                KeyValuePair<ScriptNode, ScriptNode> P;
 
                while (!(Loop is null))
                {
                    for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                    {
                        P = Loop[i];
 
                        if (!Callback(P.Key, out ScriptNode NewKey, State))
                            return false;
 
                        if (!Callback(P.Value, out ScriptNode NewValue, State))
                            return false;
 
                        if (!(NewKey is null) || !(NewValue is null))
                        {
                            Loop[i] = new KeyValuePair<ScriptNode, ScriptNode>(
                                NewKey ?? P.Key, NewValue ?? P.Value);
                        }
                    }
 
                    Loop = Loop.Next;
                }
            }
 
            if (!(this.filter is null))
            {
                ChunkNode<IFilterNode> Loop = this.filter.FirstChunk;
 
                while (!(Loop is null))
                {
                    for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                    {
                        if (!Callback(Loop[i].ScriptNode, out ScriptNode NewValue, State))
                            return false;
 
                        if (!(NewValue is null))
                        {
                            if (NewValue is IFilterNode NewFilterNode)
                                Loop[i] = NewFilterNode;
                            else
                                Loop[i] = new FilterScriptNode(NewValue);
                        }
                    }
 
                    Loop = Loop.Next;
                }
            }
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is SparqlRegularPattern Typed) ||
                this.triples is null ^ Typed.triples is null ||
                this.boundVariables is null ^ Typed.boundVariables is null ||
                this.filter is null ^ Typed.filter is null)
            {
                return false;
            }
 
            if (!(this.boundVariables is null))
            {
                IEnumerator<KeyValuePair<ScriptNode, ScriptNode>> e1 = this.boundVariables.GetEnumerator();
                IEnumerator<KeyValuePair<ScriptNode, ScriptNode>> e2 = Typed.boundVariables.GetEnumerator();
 
                try
                {
                    bool b1 = e1.MoveNext();
                    bool b2 = e2.MoveNext();
 
                    while (b1 && b2)
                    {
                        if (!e1.Current.Equals(e2.Current))
                            return false;
 
                        b1 = e1.MoveNext();
                        b2 = e2.MoveNext();
                    }
 
                    if (b1 || b2)
                        return false;
                }
                finally
                {
                    e1.Dispose();
                    e2.Dispose();
                }
            }
 
            if (!(this.filter is null))
            {
                IEnumerator<IFilterNode> e1 = this.filter.GetEnumerator();
                IEnumerator<IFilterNode> e2 = Typed.filter.GetEnumerator();
 
                try
                {
                    bool b1 = e1.MoveNext();
                    bool b2 = e2.MoveNext();
 
                    while (b1 && b2)
                    {
                        if (!e1.Current.Equals(e2.Current))
                            return false;
 
                        b1 = e1.MoveNext();
                        b2 = e2.MoveNext();
                    }
 
                    if (b1 || b2)
                        return false;
                }
                finally
                {
                    e1.Dispose();
                    e2.Dispose();
                }
            }
 
            return true;
        }
 
        public override int GetHashCode()
        {
            int Result = base.GetHashCode();
 
            if (!(this.triples is null))
            {
                foreach (SemanticQueryTriple T in this.triples)
                    Result ^= Result << 5 ^ T.GetHashCode();
            }
 
            if (!(this.boundVariables is null))
            {
                foreach (KeyValuePair<ScriptNode, ScriptNode> P in this.boundVariables)
                {
                    Result ^= Result << 5 ^ P.Key.GetHashCode();
                    Result ^= Result << 5 ^ P.Value.GetHashCode();
                }
            }
 
            if (!(this.filter is null))
            {
                foreach (IFilterNode N in this.filter)
                    Result ^= Result << 5 ^ N.GetHashCode();
            }
 
            return Result;
        }
 
        public void SetParent(ScriptNode Parent)
        {
            if (!(this.triples is null))
            {
                foreach (ISemanticTriple T in this.triples)
                {
                    if (T.Subject is SemanticScriptElement S)
                        S.Node.SetParent(Parent);
 
                    if (T.Predicate is SemanticScriptElement P)
                        P.Node.SetParent(Parent);
 
                    if (T.Object is SemanticScriptElement O)
                        O.Node.SetParent(Parent);
                }
            }
 
            if (!(this.boundVariables is null))
            {
                foreach (KeyValuePair<ScriptNode, ScriptNode> P in this.boundVariables)
                {
                    P.Key.SetParent(Parent);
                    P.Value.SetParent(Parent);
                }
            }
 
            if (!(this.filter is null))
            {
                foreach (IFilterNode P in this.filter)
                    P.ScriptNode.SetParent(Parent);
            }
        }
    }
}