FieldAggregatorEnumerator.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Persistence.Serialization;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Persistence.SQL.Groups;
 
namespace Waher.Script.Persistence.SQL.Enumerators
{
    public class FieldAggregatorEnumerator : IResultSetEnumerator
    {
        private readonly KeyValuePair<string, ScriptNode>[] additionalFields;
        private readonly bool[] additionalFieldAsynchronous;
        private readonly IResultSetEnumerator e;
        private readonly Variables variables;
        private readonly int count;
        private ObjectProperties objectVariables = null;
        private object current = null;
 
        public FieldAggregatorEnumerator(IResultSetEnumerator ItemEnumerator, Variables Variables,
            KeyValuePair<string, int>[] AdditionalFields, ScriptNode[] Columns)
        {
            this.e = ItemEnumerator;
            this.variables = Variables;
 
            this.count = AdditionalFields.Length;
 
            this.additionalFieldAsynchronous = new bool[this.count];
            this.additionalFields = new KeyValuePair<string, ScriptNode>[this.count];
 
            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);
                this.additionalFieldAsynchronous[i] = Node.IsAsynchronous;
            }
        }
 
        public object Current => this.current;
 
        public void Dispose()
        {
            this.e.Dispose();
        }
 
        public bool MoveNext()
        {
            return this.MoveNextAsync().Result;
        }
 
        public async Task<bool> MoveNextAsync()
        {
            KeyValuePair<string, ScriptNode> P;
            int i;
 
            if (!await this.e.MoveNextAsync())
                return false;
 
            this.current = this.e.Current;
 
            if (this.objectVariables is null)
                this.objectVariables = new ObjectProperties(this.current, this.variables);
            else
                this.objectVariables.Object = this.e.Current;
 
            if (this.current 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 (this.current 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);
                }
 
                this.current = Obj;
            }
 
            return true;
        }
 
        public void Reset()
        {
            this.e.Reset();
            this.current = null;
        }
    }
}