PropertyDefinition.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Persistence.Attributes;
using Waher.Persistence.Serialization;
using Waher.Runtime.Inventory;
 
namespace Waher.Persistence.FullTextSearch
{
    public enum PropertyType
    {
        Label,
 
        External
    }
 
    [TypeName(TypeNameSerialization.None)]
    public class PropertyDefinition
    {
        private readonly Dictionary<string, KeyValuePair<PropertyInfo, FieldInfo>> memberInfo = new Dictionary<string, KeyValuePair<PropertyInfo, FieldInfo>>();
        private IPropertyEvaluator evaluator;
        private bool initialized;
 
        public PropertyDefinition()
        {
        }
 
        public PropertyDefinition(string Label)
        {
            this.ExternalSource = null;
            this.Definition = Label;
            this.Type = PropertyType.Label;
        }
 
        public PropertyDefinition(string ExternalSource, string Definition)
        {
            this.ExternalSource = ExternalSource;
            this.Definition = Definition;
            this.Type = PropertyType.External;
        }
 
        public static PropertyDefinition[] ToArray(string[] PropertyNames)
        {
            int i, c = PropertyNames.Length;
            PropertyDefinition[] Result = new PropertyDefinition[c];
 
            for (i = 0; i < c; i++)
                Result[i] = new PropertyDefinition(PropertyNames[i]);
 
            return Result;
        }
 
        public string Definition { get; set; }
 
        [DefaultValueStringEmpty]
        public string ExternalSource { get; set; }
 
        public PropertyType Type { get; set; }
 
        public async Task<object> GetValue(object Instance)
        {
            if (Instance is null)
                return null;
 
            Type T;
 
            switch (this.Type)
            {
                case PropertyType.Label:
                    KeyValuePair<PropertyInfo, FieldInfo> P;
 
                    T = Instance.GetType();
 
                    lock (this.memberInfo)
                    {
                        if (!this.memberInfo.TryGetValue(T.FullName, out P))
                        {
                            P = new KeyValuePair<PropertyInfo, FieldInfo>(
                                T.GetRuntimeProperty(this.Definition),
                                T.GetRuntimeField(this.Definition));
 
                            this.memberInfo[T.FullName] = P;
                        }
                    }
 
                    if (!(P.Key is null))
                    {
                        if (P.Key.DeclaringType.IsAssignableFrom(Instance.GetType()))
                            return P.Key.GetValue(Instance);
                    }
                    else if (!(P.Value is null))
                    {
                        if (P.Value.DeclaringType.IsAssignableFrom(Instance.GetType()))
                            return P.Value.GetValue(Instance);
                    }
                    break;
 
                case PropertyType.External:
                    if (!this.initialized)
                    {
                        this.initialized = true;
 
                        T = Types.GetType(this.ExternalSource);
                        if (!(T is null))
                        {
                            this.evaluator = Types.Create(true, T) as IPropertyEvaluator;
                            if (!(this.evaluator is null))
                                await this.evaluator.Prepare(this.Definition);
                        }
 
                    }
 
                    if (!(this.evaluator is null))
                    {
                        try
                        {
                            return await this.evaluator.Evaluate(Instance);
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex);
                            return null;
                        }
                    }
                    break;
            }
 
            return null;
        }
 
        public async Task<object> GetValue(GenericObject Instance)
        {
            if (!this.initialized)
            {
                this.initialized = true;
 
                switch (this.Type)
                {
                    case PropertyType.Label:
                        break;
 
                    case PropertyType.External:
                        Type T = Types.GetType(this.ExternalSource);
                        if (!(T is null))
                        {
                            this.evaluator = Types.Create(true, T) as IPropertyEvaluator;
                            if (!(this.evaluator is null))
                                await this.evaluator.Prepare(this.Definition);
                        }
                        break;
                }
            }
 
            switch (this.Type)
            {
                case PropertyType.Label:
                    if (Instance.TryGetFieldValue(this.Definition, out object Value))
                        return Value;
                    break;
 
                case PropertyType.External:
                    if (!(this.evaluator is null))
                        return await this.evaluator.Evaluate(Instance);
                    break;
            }
 
            return null;
        }
 
    }
}