ExportToVariableTable.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.Objects;
using Waher.Script.Objects.Matrices;
 
namespace Waher.Script.Persistence.SQL.LedgerExports
{
    public class ExportToVariableTable : ILedgerExport
    {
        private readonly LinkedList<KeyValuePair<string, IElement>> collectionProperties = new LinkedList<KeyValuePair<string, IElement>>();
        private readonly LinkedList<KeyValuePair<string, IElement>> blockProperties = new LinkedList<KeyValuePair<string, IElement>>();
        private readonly LinkedList<KeyValuePair<string, IElement>> entryProperties = new LinkedList<KeyValuePair<string, IElement>>();
        private readonly LinkedList<IElement[]> rows = new LinkedList<IElement[]>();
        private readonly List<IElement> currentRow = new List<IElement>();
        private readonly List<string> headers = new List<string>();
        private readonly Dictionary<string, int> headerOrder = new Dictionary<string, int>();
        private int width;
        private int height;
        private Variables variables;
 
        public ExportToVariableTable()
        {
        }
 
        public Variables Variables
        {
            get => this.variables;
            internal set => this.variables = value;
        }
 
        public ObjectMatrix ToMatrix()
        {
            LinkedList<IElement> Elements = new LinkedList<IElement>();
 
            foreach (IElement[] Row in this.rows)
            {
                foreach (IElement E in Row)
                    Elements.AddLast(E ?? ObjectValue.Null);
 
                int Padding = this.width - Row.Length;
                while (Padding > 0)
                {
                    Elements.AddLast(ObjectValue.Null);
                    Padding--;
                }
            }
 
            return new ObjectMatrix(this.height, this.width, Elements)
            {
                ColumnNames = this.headers.ToArray()
            };
        }
 
        public Task<bool> StartLedger()
        {
            this.height = 0;
            this.width = 0;
 
            this.rows.Clear();
            this.headerOrder.Clear();
            this.headers.Clear();
 
            return Task.FromResult(true);
        }
 
        public Task<bool> EndLedger()
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> StartCollection(string CollectionName)
        {
            this.collectionProperties.Clear();
            this.collectionProperties.AddLast(new KeyValuePair<string, IElement>("Collection", new StringValue(CollectionName)));
 
            return Task.FromResult(true);
        }
 
        public Task<bool> EndCollection()
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> StartBlock(string BlockID)
        {
            this.blockProperties.Clear();
            this.blockProperties.AddLast(new KeyValuePair<string, IElement>("BlockId", new StringValue(BlockID)));
 
            return Task.FromResult(true);
        }
 
        public Task<bool> BlockMetaData(string Key, object Value)
        {
            this.blockProperties.AddLast(new KeyValuePair<string, IElement>(Key, Expression.Encapsulate(Value)));
            return Task.FromResult(true);
        }
 
        public Task<bool> EndBlock()
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> StartEntry(string ObjectId, string TypeName, EntryType EntryType, DateTimeOffset EntryTimestamp)
        {
            this.entryProperties.Clear();
            this.entryProperties.AddLast(new KeyValuePair<string, IElement>("ObjectId", new StringValue(ObjectId)));
            this.entryProperties.AddLast(new KeyValuePair<string, IElement>("TypeName", new StringValue(TypeName)));
            this.entryProperties.AddLast(new KeyValuePair<string, IElement>("EntryType", new ObjectValue(EntryType)));
            this.entryProperties.AddLast(new KeyValuePair<string, IElement>("Timestamp", new ObjectValue(EntryTimestamp)));
 
            return Task.FromResult(true);
        }
 
        public Task<bool> ReportProperty(string PropertyName, object PropertyValue)
        {
            this.entryProperties.AddLast(new KeyValuePair<string, IElement>(PropertyName, Expression.Encapsulate(PropertyValue)));
            return Task.FromResult(true);
        }
 
        public Task<bool> EndEntry()
        {
            if (this.variables is null)
                return Task.FromResult(false);
 
            this.currentRow.Clear();
 
            foreach (KeyValuePair<string, IElement> P in this.collectionProperties)
                this.AddPropertyToRow(P.Key, P.Value);
 
            foreach (KeyValuePair<string, IElement> P in this.blockProperties)
                this.AddPropertyToRow(P.Key, P.Value);
 
            foreach (KeyValuePair<string, IElement> P in this.entryProperties)
                this.AddPropertyToRow(P.Key, P.Value);
 
            this.rows.AddLast(this.currentRow.ToArray());
            this.height++;
 
            int c = this.currentRow.Count;
            if (c > this.width)
                this.width = c;
 
            return Task.FromResult(true);
        }
 
        private void AddPropertyToRow(string Name, IElement Value)
        {
            if (!this.headerOrder.TryGetValue(Name, out int i))
            {
                i = this.headers.Count;
                this.headerOrder[Name] = i;
                this.headers.Add(Name);
            }
 
            int c = this.currentRow.Count;
 
            if (c <= i)
            {
                while (c < i - 1)
                {
                    this.currentRow.Add(null);
                    c++;
                }
 
                this.currentRow.Add(Value);
            }
            else
                this.currentRow[i] = Value;
        }
 
        public Task<bool> CollectionCleared(DateTimeOffset EntryTimestamp)
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> ReportError(string Message)
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> ReportException(Exception Exception)
        {
            return Task.FromResult(true);
        }
    }
}