Query.cs

using System;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Runtime.Language;
 
namespace Waher.Things.Queries
{
    public class Query : IObservableLayer
    {
        private readonly INode nodeReference;
        private readonly Language language;
        private readonly RequestOrigin origin;
        private readonly string commandId;
        private readonly string queryId;
        private readonly object state;
        private bool isStarted = false;
        private bool isAborted = false;
        private bool isDone = false;
        private int seqNr = 0;
        private int nrSectionsBegun = 0;
        private int nrSectionsEnded = 0;
        private int nrTablesStarted = 0;
        private int nrTablesCompleted = 0;
        private int nrObjectsReported = 0;
        private int nrMessagesReported = 0;
        private int nrRecordsReported = 0;
        private bool hasTitle = false;
 
        public Query(string CommandId, string QueryId, object State, Language Language, 
            INode NodeReference, RequestOrigin Origin)
        {
            this.nodeReference = NodeReference;
            this.commandId = CommandId;
            this.queryId = QueryId;
            this.state = State;
            this.language = Language;
            this.origin = Origin;
        }
 
        public string CommandID => this.commandId;
 
        public string QueryID => this.queryId;
 
        public object State => this.state;
 
        public Language Language => this.language;
 
        public INode NodeReference => this.nodeReference;
 
        public RequestOrigin Origin => this.origin;
 
        public bool IsStarted => this.isStarted;
 
        public bool IsAborted => this.isAborted;
 
        public bool IsDone => this.isDone;
 
        public int SequenceNumber => this.seqNr;
 
        public int NrSectionsBegun => this.nrSectionsBegun;
 
        public int NrSectionsEnded => this.nrSectionsEnded;
 
        public int NrTablesStarted => this.nrTablesStarted;
 
        public int NrTablesCompleted => this.nrTablesCompleted;
 
        public int NrObjectsReported => this.nrObjectsReported;
 
        public int NrMessagesReported => this.nrMessagesReported;
 
        public int NrRecordsReported => this.nrRecordsReported;
 
        public int NrTotalItemsReported
        {
            get
            {
                int Result = this.nrSectionsBegun;
                Result += this.nrSectionsEnded;
                Result += this.NrTablesStarted;
                Result += this.nrTablesCompleted;
                Result += this.nrObjectsReported;
                Result += this.nrMessagesReported;
                Result += this.nrRecordsReported;
                return Result;
            }
        }
 
        public bool HasTitle => this.hasTitle;
 
        public bool HasReported => this.NrTotalItemsReported > 0;
 
        public int NextSequenceNumber()
        {
            return ++this.seqNr;
        }
 
        public virtual async Task Abort()
        {
            if (!this.isAborted)
            {
                this.isAborted = true;
                await this.Raise(this.OnAborted, new QueryEventArgs(this), false);
            }
        }
 
        internal Task Abort(QueryEventArgs e)
        {
            if (!this.isAborted)
            {
                this.isAborted = true;
                return this.Raise(this.OnAborted, e, false);
            }
            else
                return Task.CompletedTask;
        }
 
        private async Task Raise(EventHandlerAsync<QueryEventArgs> Callback, QueryEventArgs e, bool CheckTerminated)
        {
            if (CheckTerminated && (this.isAborted || this.isDone))
                return;
 
            await Callback.Raise(this, e);
        }
 
        public event EventHandlerAsync<QueryEventArgs> OnAborted = null;
 
        public Task Start()
        {
            if (this.isStarted)
                return Task.CompletedTask;
 
            this.isStarted = true;
            return this.Raise(this.OnStarted, new QueryEventArgs(this), false);
        }
 
        internal Task Start(QueryEventArgs e)
        {
            if (!this.isStarted)
            {
                this.isStarted = true;
                return this.Raise(this.OnStarted, e, false);
            }
            else
                return Task.CompletedTask;
        }
 
        public event EventHandlerAsync<QueryEventArgs> OnStarted = null;
 
        public async Task Done()
        {
            if (!this.isDone)
            {
                this.isDone = true;
                await this.Raise(this.OnDone, new QueryEventArgs(this), false);
            }
        }
 
        internal Task Done(QueryEventArgs e)
        {
            if (!this.isDone)
            {
                this.isDone = true;
                return this.Raise(this.OnDone, e, false);
            }
            else
                return Task.CompletedTask;
        }
 
        public event EventHandlerAsync<QueryEventArgs> OnDone = null;
 
        public Task NewTable(string TableId, string TableName, params Column[] Columns)
        {
            this.nrTablesStarted++;
            return this.Raise(this.OnNewTable, new QueryNewTableEventArgs(this, TableId, TableName, Columns));
        }
 
        internal Task NewTable(QueryNewTableEventArgs e)
        {
            this.nrTablesStarted++;
            return this.Raise(this.OnNewTable, e);
        }
 
        private async Task Raise(EventHandlerAsync<QueryNewTableEventArgs> Callback, QueryNewTableEventArgs e)
        {
            if (!this.isAborted && !this.isDone)
                await Callback.Raise(this, e);
        }
 
        public event EventHandlerAsync<QueryNewTableEventArgs> OnNewTable = null;
 
        public Task NewRecords(string TableId, params Record[] Records)
        {
            this.nrRecordsReported += Records.Length;
            return this.Raise(this.OnNewRecords, new QueryNewRecordsEventArgs(this, TableId, Records));
        }
 
        internal Task NewRecords(QueryNewRecordsEventArgs e)
        {
            this.nrRecordsReported += e.Records.Length;
            return this.Raise(this.OnNewRecords, e);
        }
 
        private async Task Raise(EventHandlerAsync<QueryNewRecordsEventArgs> Callback, QueryNewRecordsEventArgs e)
        {
            if (!this.isAborted && !this.isDone)
                await Callback.Raise(this, e);
        }
 
        public event EventHandlerAsync<QueryNewRecordsEventArgs> OnNewRecords = null;
 
        public Task TableDone(string TableId)
        {
            this.nrTablesCompleted++;
            return this.Raise(this.OnTableDone, new QueryTableEventArgs(this, TableId));
        }
 
        internal Task TableDone(QueryTableEventArgs e)
        {
            this.nrTablesCompleted++;
            return this.Raise(this.OnTableDone, e);
        }
 
        private async Task Raise(EventHandlerAsync<QueryTableEventArgs> Callback, QueryTableEventArgs e)
        {
            if (!this.isAborted && !this.isDone)
                await Callback.Raise(this, e);
        }
 
        public event EventHandlerAsync<QueryTableEventArgs> OnTableDone = null;
 
        public Task NewObject(object Object)
        {
            this.nrObjectsReported++;
            return this.Raise(this.OnNewObject, new QueryObjectEventArgs(this, Object));
        }
 
        internal Task NewObject(QueryObjectEventArgs e)
        {
            this.nrObjectsReported++;
            return this.Raise(this.OnNewObject, e);
        }
 
        private async Task Raise(EventHandlerAsync<QueryObjectEventArgs> Callback, QueryObjectEventArgs e)
        {
            if (!this.isAborted && !this.isDone)
                await Callback.Raise(this, e);
        }
 
        public event EventHandlerAsync<QueryObjectEventArgs> OnNewObject = null;
 
        public Task LogMessage(Exception Exception)
        {
            return this.LogMessage(QueryEventLevel.Major, Exception);
        }
 
        public Task LogMessage(QueryEventLevel Level, Exception Exception)
        {
            Exception = Log.UnnestException(Exception);
            return this.LogMessage(QueryEventType.Exception, Level, Exception.Message);
        }
 
        public Task LogMessage(QueryEventType Type, QueryEventLevel Level, string Body)
        {
            this.nrMessagesReported++;
            return this.Raise(this.OnMessage, new QueryMessageEventArgs(this, Type, Level, Body));
        }
 
        internal Task LogMessage(QueryMessageEventArgs e)
        {
            this.nrMessagesReported++;
            return this.Raise(this.OnMessage, e);
        }
 
        private async Task Raise(EventHandlerAsync<QueryMessageEventArgs> Callback, QueryMessageEventArgs e)
        {
            if (!this.isAborted && !this.isDone)
                await Callback.Raise(this, e);
        }
 
        public event EventHandlerAsync<QueryMessageEventArgs> OnMessage = null;
 
        public Task SetTitle(string Title)
        {
            this.hasTitle = true;
            return this.Raise(this.OnTitle, new QueryTitleEventArgs(this, Title));
        }
 
        internal Task SetTitle(QueryTitleEventArgs e)
        {
            this.hasTitle = true;
            return this.Raise(this.OnTitle, e);
        }
 
        private async Task Raise(EventHandlerAsync<QueryTitleEventArgs> Callback, QueryTitleEventArgs e)
        {
            if (!this.isAborted && !this.isDone)
                await Callback.Raise(this, e);
        }
 
        public event EventHandlerAsync<QueryTitleEventArgs> OnTitle = null;
 
        public Task SetStatus(string Status)
        {
            return this.Raise(this.OnStatus, new QueryStatusEventArgs(this, Status));
        }
 
        internal Task SetStatus(QueryStatusEventArgs e)
        {
            return this.Raise(this.OnStatus, e);
        }
 
        private async Task Raise(EventHandlerAsync<QueryStatusEventArgs> h, QueryStatusEventArgs e)
        {
            if (!this.isAborted && !this.isDone)
                await h.Raise(this, e);
        }
 
        public event EventHandlerAsync<QueryStatusEventArgs> OnStatus = null;
 
        public Task BeginSection(string Header)
        {
            this.nrSectionsBegun++;
            return this.Raise(this.OnBeginSection, new QueryTitleEventArgs(this, Header));
        }
 
        internal Task BeginSection(QueryTitleEventArgs e)
        {
            this.nrSectionsBegun++;
            return this.Raise(this.OnBeginSection, e);
        }
 
        public event EventHandlerAsync<QueryTitleEventArgs> OnBeginSection = null;
 
        public Task EndSection()
        {
            this.nrSectionsEnded++;
            return this.Raise(this.OnEndSection, new QueryEventArgs(this), true);
        }
 
        internal Task EndSection(QueryEventArgs e)
        {
            this.nrSectionsEnded++;
            return this.Raise(this.OnEndSection, e, true);
        }
 
        public event EventHandlerAsync<QueryEventArgs> OnEndSection = null;
 
        #region ICommunicationLayer
 
        public bool DecoupledEvents => false;
 
        public void Information(string Comment) => this.LogMessage(QueryEventType.Information, QueryEventLevel.Minor, Comment);
 
        public void Warning(string Warning) => this.LogMessage(QueryEventType.Warning, QueryEventLevel.Minor, Warning);
 
        public void Error(string Error) => this.LogMessage(QueryEventType.Error, QueryEventLevel.Minor, Error);
 
        public void Exception(Exception Exception) => this.LogMessage(QueryEventType.Exception, QueryEventLevel.Minor, Exception.Message);
 
        public void Exception(string Exception) => this.LogMessage(QueryEventType.Exception, QueryEventLevel.Minor, Exception);
 
        public void Information(DateTime Timestamp, string Comment) => this.LogMessage(QueryEventType.Information, QueryEventLevel.Minor, Comment);
 
        public void Warning(DateTime Timestamp, string Warning) => this.LogMessage(QueryEventType.Warning, QueryEventLevel.Minor, Warning);
 
        public void Error(DateTime Timestamp, string Error) => this.LogMessage(QueryEventType.Error, QueryEventLevel.Minor, Error);
 
        public void Exception(DateTime Timestamp, string Exception) => this.LogMessage(QueryEventType.Exception, QueryEventLevel.Minor, Exception);
 
        public void Exception(DateTime Timestamp, Exception Exception) => this.LogMessage(QueryEventType.Exception, QueryEventLevel.Minor, Exception.Message);
 
        #endregion
    }
}