RequiredKeyword.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Persistence.FullTextSearch.Orders;
 
namespace Waher.Persistence.FullTextSearch.Keywords
{
    public class RequiredKeyword : Keyword
    {
        public RequiredKeyword(Keyword Keyword)
            : base()
        {
            this.Keyword = Keyword;
        }
 
        public Keyword Keyword { get; }
 
        public override bool Optional => false;
 
        public override bool Required => true;
 
        public override int OrderCategory => 1;
 
        public override int OrderComplexity => this.Keyword.OrderComplexity;
 
        public override bool Ignore => this.Keyword.Ignore;
 
        public override bool Equals(object obj)
        {
            return obj is RequiredKeyword k && this.Keyword.Equals(k.Keyword);
        }
 
        public override string ToString()
        {
            return "+" + this.Keyword.ToString();
        }
 
        public override Task<IEnumerable<KeyValuePair<string, TokenReferences>>> GetTokenReferences(SearchProcess Process)
        {
            return this.Keyword.GetTokenReferences(Process);
        }
 
        public override async Task<bool> Process(SearchProcess Process)
        {
            IEnumerable<KeyValuePair<string, TokenReferences>> Records = await this.GetTokenReferences(Process);
 
            foreach (KeyValuePair<string, TokenReferences> Rec in Records)
            {
                string Token = Rec.Key;
                TokenReferences References = Rec.Value;
 
                int j, d = References.ObjectReferences.Length;
 
                for (j = 0; j < d; j++)
                {
                    ulong ObjectReference = References.ObjectReferences[j];
 
                    if (Process.IsRestricted)
                        Process.Found[ObjectReference] = true;
 
                    if (!Process.ReferencesByObject.TryGetValue(ObjectReference, out MatchInformation ByObjectReference))
                    {
                        if (Process.IsRestricted)
                            continue;
 
                        ByObjectReference = new MatchInformation();
                        Process.ReferencesByObject[ObjectReference] = ByObjectReference;
                    }
 
                    ByObjectReference.AddTokenReference(new TokenReference()
                    {
                        Count = References.Counts[j],
                        LastBlock = References.LastBlock,
                        ObjectReference = ObjectReference,
                        Timestamp = References.Timestamps[j],
                        Token = Token
                    });
                }
            }
 
            if (Process.IsRestricted)
            {
                LinkedList<ulong> ToRemove = null;
 
                foreach (ulong ObjectReference in Process.ReferencesByObject.Keys)
                {
                    if (!Process.Found.ContainsKey(ObjectReference))
                    {
                        if (ToRemove is null)
                            ToRemove = new LinkedList<ulong>();
 
                        ToRemove.AddLast(ObjectReference);
                    }
                }
 
                if (!(ToRemove is null))
                {
                    foreach (ulong ObjectReference in ToRemove)
                        Process.ReferencesByObject.Remove(ObjectReference);
                }
            }
 
            if (Process.ReferencesByObject.Count == 0)
                return false;
 
            Process.IncRestricted();
 
            return true;
        }
 
    }
}