EventsRoot.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Networking;
using Waher.Networking.Sniffers;
using Waher.Reports;
using Waher.Runtime.Language;
 
namespace Waher.Service.IoTBroker.Sources.Reports.Events
{
    public class EventsRoot : ServerAdminReportsFolder, ICommunicationLayer
    {
        private readonly List<ISniffer> sniffers = new List<ISniffer>();
        private ISniffer[] sniffersStatic = Array.Empty<ISniffer>();
        private bool hasSniffers = false;
 
        public EventsRoot()
            : base("Events", null)
        {
        }
 
        public override Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(XmppServerModule), 43, "Events");
        }
 
        public static async Task RegisterReports()
        {
            EventsRoot Root = new EventsRoot();
            new EventStatisticsNode(Root);
            new SearchEventLogNode(Root);
 
            await ReportsDataSource.RegisterRootNode(Root);
        }
 
        #region ICommunicationLayer
 
        public bool DecoupledEvents => false;
 
        public void Add(ISniffer Sniffer)
        {
            lock (this.sniffers)
            {
                if (!this.sniffers.Contains(Sniffer))
                {
                    Log.Register(new EventSinkToSniffer(Sniffer));
                    this.sniffers.Add(Sniffer);
                    this.sniffersStatic = this.sniffers.ToArray();
                    this.hasSniffers = true;
                }
            }
        }
 
        public void AddRange(IEnumerable<ISniffer> Sniffers)
        {
            foreach (ISniffer Sniffer in Sniffers)
                this.Add(Sniffer);
        }
 
        public bool Remove(ISniffer Sniffer)
        {
            lock (this.sniffers)
            {
                if (!this.sniffers.Remove(Sniffer))
                    return false;
 
                this.sniffersStatic = this.sniffers.ToArray();
                this.hasSniffers = this.sniffers.Count > 0;
            }
 
            foreach (IEventSink Sink in Log.Sinks)
            {
                if (Sink is EventSinkToSniffer EventSinkToSniffer &&
                    EventSinkToSniffer.Sniffer == Sniffer)
                {
                    Log.Unregister(Sink);
                    return true;
                }
            }
 
            return false;
        }
 
        public ISniffer[] Sniffers => this.sniffersStatic;
 
        public bool HasSniffers => this.hasSniffers;
 
        public IEnumerator<ISniffer> GetEnumerator()
        {
            return (IEnumerator<ISniffer>)this.sniffersStatic.GetEnumerator();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            lock (this.sniffers)
            {
                return this.sniffersStatic.GetEnumerator();
            }
        }
 
        public void ReceiveBinary(int Count)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.ReceiveBinary(Count);
            }
        }
 
        public void ReceiveBinary(bool ConstantBuffer, byte[] Data)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.ReceiveBinary(ConstantBuffer, Data);
            }
        }
 
        public void ReceiveBinary(bool ConstantBuffer, byte[] Data, int Offset, int Count)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.ReceiveBinary(ConstantBuffer, Data, Offset, Count);
            }
        }
 
        public void TransmitBinary(int Count)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.TransmitBinary(Count);
            }
        }
 
        public void TransmitBinary(bool ConstantBuffer, byte[] Data)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.TransmitBinary(ConstantBuffer, Data);
            }
        }
 
        public void TransmitBinary(bool ConstantBuffer, byte[] Data, int Offset, int Count)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.TransmitBinary(ConstantBuffer, Data, Offset, Count);
            }
        }
 
        public void ReceiveText(string Text)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.ReceiveText(Text);
            }
        }
 
        public void TransmitText(string Text)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.TransmitText(Text);
            }
        }
 
        public void Information(string Comment)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.Information(Comment);
            }
        }
 
        public void Warning(string Warning)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.Warning(Warning);
            }
        }
 
        public void Error(string Error)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.Error(Error);
            }
        }
 
        public void Exception(Exception Exception)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.Exception(Exception);
            }
        }
 
        public void Exception(string Exception)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.Exception(Exception);
            }
        }
 
        public void ReceiveBinary(DateTime Timestamp, int Count)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.ReceiveBinary(Timestamp, Count);
            }
        }
 
        public void ReceiveBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.ReceiveBinary(Timestamp, ConstantBuffer, Data);
            }
        }
 
        public void ReceiveBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data, int Offset, int Count)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.ReceiveBinary(Timestamp, ConstantBuffer, Data, Offset, Count);
            }
        }
 
        public void TransmitBinary(DateTime Timestamp, int Count)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.TransmitBinary(Timestamp, Count);
            }
        }
 
        public void TransmitBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.TransmitBinary(Timestamp, ConstantBuffer, Data);
            }
        }
 
        public void TransmitBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data, int Offset, int Count)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.TransmitBinary(Timestamp, ConstantBuffer, Data, Offset, Count);
            }
        }
 
        public void ReceiveText(DateTime Timestamp, string Text)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.ReceiveText(Timestamp, Text);
            }
        }
 
        public void TransmitText(DateTime Timestamp, string Text)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.TransmitText(Timestamp, Text);
            }
        }
 
        public void Information(DateTime Timestamp, string Comment)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.Information(Timestamp, Comment);
            }
        }
 
        public void Warning(DateTime Timestamp, string Warning)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.Warning(Timestamp, Warning);
            }
        }
 
        public void Error(DateTime Timestamp, string Error)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.Error(Timestamp, Error);
            }
        }
 
        public void Exception(DateTime Timestamp, string Exception)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.Exception(Timestamp, Exception);
            }
        }
 
        public void Exception(DateTime Timestamp, Exception Exception)
        {
            if (this.hasSniffers)
            {
                foreach (ISniffer Sniffer in this.sniffersStatic)
                    Sniffer.Exception(Timestamp, Exception);
            }
        }
 
        #endregion
    }
}