FieldAggregatorProcessor.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Persistence.Serialization;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Persistence.SQL.Groups;
 
namespace Waher.Script.Persistence.SQL.Processors
{
    public class FieldAggregatorProcessor : IProcessor<object>
    {
        private readonly KeyValuePair<string, ScriptNode>[] additionalFields;
        private readonly bool[] additionalFieldAsynchronous;
        private readonly IProcessor<object> processor;
        private readonly Variables variables;
        private readonly int count;
        private readonly bool isAsynchronous;
        private ObjectProperties objectVariables = null;
 
        public FieldAggregatorProcessor(IProcessor<object> Processor, Variables Variables,
            KeyValuePair<string, int>[] AdditionalFields, ScriptNode[] Columns)
        {
            this.processor = Processor;
            this.variables = Variables;
 
            this.count = AdditionalFields.Length;
 
            this.additionalFieldAsynchronous = new bool[this.count];
            this.additionalFields = new KeyValuePair<string, ScriptNode>[this.count];
            this.isAsynchronous = Processor.IsAsynchronous;
 
            for (int i = 0; i < this.count; i++)
            {
                KeyValuePair<string, int> P = AdditionalFields[i];
                ScriptNode Node = Columns[P.Value];
 
                this.additionalFields[i] = new KeyValuePair<string, ScriptNode>(P.Key, Node);
 
                if (this.additionalFieldAsynchronous[i] = Node.IsAsynchronous)
                    this.isAsynchronous = true;
            }
        }
 
        public bool IsAsynchronous => this.isAsynchronous;
 
        public bool Process(object Object)
        {
            KeyValuePair<string, ScriptNode> P;
            int i;
 
            if (this.objectVariables is null)
                this.objectVariables = new ObjectProperties(Object, this.variables);
            else
                this.objectVariables.Object = Object;
 
            if (Object is GenericObject GenObj)
            {
                for (i = 0; i < this.count; i++)
                {
                    P = this.additionalFields[i];
                    GenObj[P.Key] = P.Value.Evaluate(this.objectVariables);
                }
            }
            else if (Object is GroupObject GroupObj)
            {
                for (i = 0; i < this.count; i++)
                {
                    P = this.additionalFields[i];
                    GroupObj[P.Key] = P.Value.Evaluate(this.objectVariables);
                }
            }
            else
            {
                GroupObject Obj = new GroupObject(Array.Empty<object>(), Array.Empty<IElement>(), 
                    Array.Empty<ScriptNode>(), this.objectVariables);
 
                for (i = 0; i < this.count; i++)
                {
                    P = this.additionalFields[i];
                    Obj[P.Key] = P.Value.Evaluate(this.objectVariables);
                }
 
                Object = Obj;
            }
 
            return this.processor.Process(Object);
        }
 
        public async Task<bool> ProcessAsync(object Object)
        {
            KeyValuePair<string, ScriptNode> P;
            int i;
 
            if (this.objectVariables is null)
                this.objectVariables = new ObjectProperties(Object, this.variables);
            else
                this.objectVariables.Object = Object;
 
            if (Object is GenericObject GenObj)
            {
                for (i = 0; i < this.count; i++)
                {
                    P = this.additionalFields[i];
 
                    if (this.additionalFieldAsynchronous[i])
                        GenObj[P.Key] = await P.Value.EvaluateAsync(this.objectVariables);
                    else
                        GenObj[P.Key] = P.Value.Evaluate(this.objectVariables);
                }
            }
            else if (Object is GroupObject GroupObj)
            {
                for (i = 0; i < this.count; i++)
                {
                    P = this.additionalFields[i];
 
                    if (this.additionalFieldAsynchronous[i])
                        GroupObj[P.Key] = await P.Value.EvaluateAsync(this.objectVariables);
                    else
                        GroupObj[P.Key] = P.Value.Evaluate(this.objectVariables);
                }
            }
            else
            {
                GroupObject Obj = new GroupObject(Array.Empty<object>(), Array.Empty<IElement>(), 
                    Array.Empty<ScriptNode>(), this.objectVariables);
 
                for (i = 0; i < this.count; i++)
                {
                    P = this.additionalFields[i];
 
                    if (this.additionalFieldAsynchronous[i])
                        Obj[P.Key] = await P.Value.EvaluateAsync(this.objectVariables);
                    else
                        Obj[P.Key] = P.Value.Evaluate(this.objectVariables);
                }
 
                Object = Obj;
            }
 
            return await this.processor.ProcessAsync(Object);
        }
 
        public bool Flush() => this.processor.Flush();
 
        public Task<bool> FlushAsync() => this.processor.FlushAsync();
    }
}