GraphPattern.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content.Semantic;
using Waher.Content.Semantic.Model;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Persistence.SQL;
 
namespace Waher.Script.Persistence.SPARQL.Patterns
{
    public class GraphPattern : ISparqlPattern
    {
        private readonly ISparqlPattern pattern;
        private ScriptNode graph;
        private bool graphIsVariableRef;
        private string graphVariableRef;
 
        public GraphPattern(ScriptNode Graph, ISparqlPattern Pattern)
        {
            this.graph = Graph;
            this.pattern = Pattern;
 
            this.CheckGraphVariableReference();
        }
 
        private void CheckGraphVariableReference()
        {
            if (this.graph is VariableReference Ref)
            {
                this.graphIsVariableRef = true;
                this.graphVariableRef = Ref.VariableName;
            }
            else
            {
                this.graphIsVariableRef = false;
                this.graphVariableRef = null;
            }
        }
 
        public bool IsEmpty => false;
 
        public async Task<IEnumerable<Possibility>> Search(ISemanticCube Cube,
            Variables Variables, IEnumerable<Possibility> ExistingMatches, SparqlQuery Query)
        {
            ObjectProperties ObjectProperties = null;
            IElement Graph;
 
            if (ExistingMatches is null)
            {
                if (this.graphIsVariableRef &&
                    !Variables.ContainsVariable(this.graphVariableRef))
                {
                    LinkedList<Possibility> Result = new LinkedList<Possibility>();
 
                    foreach (UriNode GraphName in Query.NamedGraphNames)
                    {
                        Cube = await Query.GetNamedGraph(GraphName, Variables);
 
                        if (!(Cube is null))
                        {
                            Possibility P = new Possibility(this.graphVariableRef, GraphName);
 
                            if (ObjectProperties is null)
                                ObjectProperties = new ObjectProperties(P, Variables);
                            else
                                ObjectProperties.Object = P;
 
                            IEnumerable<Possibility> PartResult = await this.pattern.Search(
                                Cube, ObjectProperties, new Possibility[] { P }, Query);
 
                            if (!(PartResult is null))
                            {
                                foreach (Possibility P2 in PartResult)
                                    Result.AddLast(P2);
                            }
                        }
                    }
 
                    return Result;
                }
                else
                {
                    Graph = await this.graph.EvaluateAsync(Variables);
                    Cube = await Query.GetNamedGraph(Graph.AssociatedObjectValue, Variables);
                    return await this.pattern.Search(Cube, Variables, ExistingMatches, Query);
                }
            }
            else
            {
                LinkedList<Possibility> Result = new LinkedList<Possibility>();
 
                foreach (Possibility P in ExistingMatches)
                {
                    if (ObjectProperties is null)
                        ObjectProperties = new ObjectProperties(P, Variables);
                    else
                        ObjectProperties.Object = P;
 
                    if (!this.graphIsVariableRef ||
                        ObjectProperties.ContainsVariable(this.graphVariableRef))
                    {
                        Graph = await this.graph.EvaluateAsync(ObjectProperties);
                        Cube = await Query.GetNamedGraph(Graph.AssociatedObjectValue, Variables);
 
                        if (!(Cube is null))
                        {
                            IEnumerable<Possibility> PartResult = await this.pattern.Search(
                                Cube, ObjectProperties, new Possibility[] { P }, Query);
 
                            if (!(PartResult is null))
                            {
                                foreach (Possibility P2 in PartResult)
                                    Result.AddLast(P2);
                            }
                        }
                    }
                    else
                    {
                        foreach (UriNode GraphName in Query.NamedGraphNames)
                        {
                            Cube = await Query.GetNamedGraph(GraphName, Variables);
 
                            if (!(Cube is null))
                            {
                                IEnumerable<Possibility> PartResult = await this.pattern.Search(
                                    Cube, ObjectProperties, new Possibility[]
                                    {
                                        new Possibility(this.graphVariableRef, GraphName, P)
                                    }, Query);
 
                                if (!(PartResult is null))
                                {
                                    foreach (Possibility P2 in PartResult)
                                        Result.AddLast(P2);
                                }
                            }
                        }
                    }
                }
 
                return Result;
            }
        }
 
        public void SetParent(ScriptNode Parent)
        {
            this.graph.SetParent(Parent);
            this.pattern.SetParent(Parent);
        }
 
        public bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            if (Order == SearchMethod.DepthFirst)
            {
                this.graph.ForAllChildNodes(Callback, State, Order);
                this.pattern.ForAllChildNodes(Callback, State, Order);
            }
 
            this.ForAll(Callback, State, Order);
 
            if (Order == SearchMethod.BreadthFirst)
            {
                this.graph.ForAllChildNodes(Callback, State, Order);
                this.pattern.ForAllChildNodes(Callback, State, Order);
            }
 
            return true;
        }
 
        public bool ForAll(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            if (!Callback(this.graph, out ScriptNode NewNode, State))
                return false;
 
            if (!(NewNode is null))
            {
                this.graph = NewNode;
                this.CheckGraphVariableReference();
            }
 
            if (!this.pattern.ForAll(Callback, State, Order))
                return false;
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            return obj is GraphPattern Typed &&
                this.graph.Equals(Typed.graph) &&
                this.pattern.Equals(Typed.pattern);
        }
 
        public override int GetHashCode()
        {
            int Result = typeof(GraphPattern).GetHashCode();
            Result ^= Result << 5 ^ this.graph.GetHashCode();
            Result ^= Result << 5 ^ this.pattern.GetHashCode();
            return Result;
        }
    }
}