CachedEventHandler.cs

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Cache;
using Waher.Service.IoTBroker.StateMachines.Model;
 
namespace Waher.Service.IoTBroker.StateMachines.EventHandlers
{
    public abstract class CachedEventHandler : EventHandler
    {
        private static readonly Cache<string, Dictionary<string, CachedEventHandler>> eventHandlers = new Cache<string, Dictionary<string, CachedEventHandler>>(int.MaxValue, TimeSpan.FromDays(1), TimeSpan.FromHours(8));
        private static readonly SemaphoreSlim synchObj = new SemaphoreSlim(1);
 
        public CachedEventHandler()
            : base()
        {
        }
 
        public CachedEventHandler(EvaluationArguments Arguments, int EventIndex)
            : base(Arguments, EventIndex)
        {
        }
 
        public async Task AddToCache()
        {
            await synchObj.WaitAsync();
            try
            {
                if (!eventHandlers.TryGetValue(this.EventType, out Dictionary<string, CachedEventHandler> Handlers))
                {
                    Handlers = await LoadEventHandlers(this.EventType);
 
                    if (!Handlers.ContainsKey(this.ObjectId))
                        Handlers[this.ObjectId] = this;
 
                    eventHandlers[this.EventType] = Handlers;
                }
                else if (Handlers is null)
                {
                    Handlers = new Dictionary<string, CachedEventHandler>()
                    {
                        { this.ObjectId, this }
                    };
 
                    eventHandlers[this.EventType] = Handlers;
                }
                else
                    Handlers[this.ObjectId] = this;
            }
            finally
            {
                synchObj.Release();
            }
        }
 
        public async Task RemoveFromCache()
        {
            await synchObj.WaitAsync();
            try
            {
                if (eventHandlers.TryGetValue(this.EventType, out Dictionary<string, CachedEventHandler> Handlers) &&
                    !(Handlers is null) &&
                    Handlers.Remove(this.ObjectId) &&
                    Handlers.Count == 0)
                {
                    eventHandlers[this.EventType] = null;
                }
            }
            finally
            {
                synchObj.Release();
            }
        }
 
        public static async Task<CachedEventHandler[]> GetEventHandlers(string EventType)
        {
            await synchObj.WaitAsync();
            try
            {
                if (!eventHandlers.TryGetValue(EventType, out Dictionary<string, CachedEventHandler> Handlers))
                {
                    Dictionary<string, CachedEventHandler> List = await LoadEventHandlers(EventType);
                    Handlers = List.Count == 0 ? null : List;
                    eventHandlers[EventType] = Handlers;
                }
 
                if (Handlers is null)
                    return null;
 
                int c = Handlers.Count;
                CachedEventHandler[] Result = new CachedEventHandler[c];
                Handlers.Values.CopyTo(Result, 0);
 
                return Result;
            }
            finally
            {
                synchObj.Release();
            }
        }
 
        private static async Task<Dictionary<string, CachedEventHandler>> LoadEventHandlers(string EventType)
        {
            IEnumerable<CachedEventHandler> Handlers = await Database.Find<CachedEventHandler>(new FilterFieldEqualTo("EventType", EventType));
            Dictionary<string, CachedEventHandler> Result = new Dictionary<string, CachedEventHandler>();
 
            foreach (CachedEventHandler Handler in Handlers)
                Result[Handler.ObjectId] = Handler;
 
            return Result;
        }
 
    }
}