NotExists.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content.Semantic;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Persistence.SPARQL.Patterns;
 
namespace Waher.Script.Persistence.SPARQL.Filters
{
    public class NotExists : ScriptNode, IFilterNode
    {
        private readonly ISparqlPattern pattern;
 
        public NotExists(ISparqlPattern Pattern, int Start, int Length, Expression Expression)
            : base(Start, Length, Expression)
        {
            this.pattern = Pattern;
        }
 
        public override bool IsAsynchronous => true;
 
        public override IElement Evaluate(Variables Variables)
        {
            return BooleanValue.False;
        }
 
        public override Task<IElement> EvaluateAsync(Variables Variables)
        {
            return Task.FromResult<IElement>(BooleanValue.False);
        }
 
        public async Task<IElement> EvaluateAsync(Variables Variables, ISemanticCube Cube,
            SparqlQuery Query, Possibility Possibility)
        {
            IEnumerable<Possibility> Possibilities = await this.pattern.Search(Cube, Variables, 
                new Possibility[] { Possibility }, Query);
            if (Possibilities is null)
                return BooleanValue.True;
 
            using (IEnumerator<Possibility> e = Possibilities.GetEnumerator())
            {
                return e.MoveNext() ? BooleanValue.False : BooleanValue.True;
            }
        }
 
        public ScriptNode ScriptNode => this;
 
        public override bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            if (Order == SearchMethod.DepthFirst)
            {
                if (!this.pattern.ForAllChildNodes(Callback, State, Order))
                    return false;
            }
 
            if (!this.pattern.ForAll(Callback, State, Order))
                return false;
 
            if (Order == SearchMethod.BreadthFirst)
            {
                if (!this.pattern.ForAllChildNodes(Callback, State, Order))
                    return false;
            }
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            return obj is NotExists O &&
                this.pattern.Equals(O.pattern) &&
                base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            int Result = base.GetHashCode();
            Result ^= Result << 5 ^ this.pattern.GetHashCode();
            return Result;
        }
    }
}