HumanReadableTextsTokenizer.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Persistence.FullTextSearch;
using Waher.Persistence.FullTextSearch.Tokenizers;
using Waher.Persistence.Serialization;
using Waher.Runtime.Collections;
using Waher.Runtime.Inventory;
using Waher.Service.IoTBroker.Legal.HumanReadable;
 
namespace Waher.Service.IoTBroker.Legal.Contracts.Tokenizers
{
    public class HumanReadableTextsTokenizer : ITokenizer, IPropertyEvaluator
    {
        public HumanReadableTextsTokenizer()
        {
        }
 
        public Grade Supports(Type Type)
        {
            if (typeInfo.IsAssignableFrom(Type))
                return Grade.Ok;
            else
                return Grade.NotAtAll;
        }
 
        private static readonly TypeInfo typeInfo = typeof(IEnumerable<HumanReadableText>).GetTypeInfo();
 
        public async Task Tokenize(object Value, TokenizationProcess Process)
        {
            if (Value is IEnumerable<HumanReadableText> HumanReadableTexts)
                await Tokenize(HumanReadableTexts, null, Process);
        }
 
        public static async Task Tokenize(IEnumerable<HumanReadableText> HumanReadableTexts,
            Contract Contract, TokenizationProcess Process)
        {
            if (!(HumanReadableTexts is null))
            {
                foreach (HumanReadableText HumanReadableText in HumanReadableTexts)
                {
                    await HumanReadableTextTokenizer.Tokenize(HumanReadableText, Contract, Process);
                    Process.DocumentIndexOffset++;  // Make sure sequences of keywords don't cross element boundaries.
                }
            }
        }
 
        public Task Prepare(string Definition)
        {
            return Task.CompletedTask;
        }
 
        public async Task<object> Evaluate(object Instance)
        {
            if (Instance is Contract Contract)
                return Contract.ForHumans;
            else if (Instance is GenericObject Obj)
            {
                if (Obj.TryGetFieldValue("ForHumans", out object Obj2) &&
                    Obj2 is Array A)
                {
                    if (A.Length == 0)
                        return Array.Empty<HumanReadableText>();
 
                    ChunkedList<HumanReadableText> HumanReadableTexts = new ChunkedList<HumanReadableText>(A.Length);
 
                    foreach (object Item in A)
                    {
                        if (Item is GenericObject GenHumanReadableText &&
                            await Database.Specialize(GenHumanReadableText) is HumanReadableText HumanReadableText)
                        {
                            HumanReadableTexts.Add(HumanReadableText);
                        }
                        else if (Item is HumanReadableText HumanReadableText2)
                            HumanReadableTexts.Add(HumanReadableText2);
                    }
 
                    return HumanReadableTexts;
                }
 
                return null;
            }
            else if (Instance is IEnumerable<HumanReadableText> HumanReadableTexts)
                return HumanReadableTexts;
            else
                return null;
        }
    }
}