Ledger.cs

using System;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Persistence.Serialization;
using Waher.Runtime.Profiling;
 
namespace Waher.Persistence
{
    public static class Ledger
    {
        private static ILedgerProvider provider = null;
        private static bool locked = false;
 
        public static void Register(ILedgerProvider LedgerProvider)
        {
            Register(LedgerProvider, true);
        }
 
        public static void Register(ILedgerProvider LedgerProvider, bool Lock)
        {
            if (!(provider is null))
            {
                if (locked)
                    throw new Exception("A ledger provider is already registered.");
 
                provider.Unregister(externalEvents);
            }
 
            provider = LedgerProvider;
            locked = Lock;
 
            provider.Register(externalEvents);
        }
 
        private static readonly ExternalEvents externalEvents = new ExternalEvents();
 
        private class ExternalEvents : ILedgerExternalEvents
        {
            public void RaiseEntryAdded(object Object)
            {
                Ledger.RaiseEntryAdded(Object);
            }
 
            public void RaiseEntryDeleted(object Object)
            {
                Ledger.RaiseEntryDeleted(Object);
            }
 
            public void RaiseEntryUpdated(object Object)
            {
                Ledger.RaiseEntryUpdated(Object);
            }
 
            public void RaiseCollectionCleared(string Collection)
            {
                Ledger.RaiseCollectionCleared(Collection);
            }
        }
 
        public static ILedgerProvider Provider
        {
            get
            {
                if (!(provider is null))
                    return provider;
                else
                    throw new Exception("A ledger provider has not been registered.");
            }
        }
 
        internal static ILedgerProvider Stop()
        {
            ILedgerProvider Result = provider;
            provider = new NullLedgerProvider();
            locked = false;
            return Result;
        }
 
        public static bool HasProvider
        {
            get => !(provider is null) && (!(provider is NullLedgerProvider) || locked);
        }
 
        public static bool Locked => locked;
 
        public static async Task NewEntry(object Object)
        {
            await Provider.NewEntry(Object);
            RaiseEntryAdded(Object);
        }
 
        private static void RaiseEntryAdded(object Object)
        {
            ObjectEventHandler h = EntryAdded;
            if (!(h is null))
            {
                try
                {
                    h(Provider, new ObjectEventArgs(Object));
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
        }
 
        public static event ObjectEventHandler EntryAdded = null;
 
        public static async Task UpdatedEntry(object Object)
        {
            await Provider.UpdatedEntry(Object);
            RaiseEntryUpdated(Object);
        }
 
        private static void RaiseEntryUpdated(object Object)
        {
            ObjectEventHandler h = EntryUpdated;
            if (!(h is null))
            {
                try
                {
                    h(Provider, new ObjectEventArgs(Object));
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
        }
 
        public static event ObjectEventHandler EntryUpdated = null;
 
        public static async Task DeletedEntry(object Object)
        {
            await Provider.DeletedEntry(Object);
            RaiseEntryDeleted(Object);
        }
 
        private static void RaiseEntryDeleted(object Object)
        {
            ObjectEventHandler h = EntryDeleted;
            if (!(h is null))
            {
                try
                {
                    h(Provider, new ObjectEventArgs(Object));
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
        }
 
        public static event ObjectEventHandler EntryDeleted = null;
 
        public static async Task ClearedCollection(string Collection)
        {
            await Provider.ClearedCollection(Collection);
            RaiseCollectionCleared(Collection);
        }
 
        private static async void RaiseCollectionCleared(string Collection)
        {
            CollectionEventHandler h = CollectionCleared;
            if (!(h is null))
            {
                try
                {
                    await h(Provider, new CollectionEventArgs(Collection));
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
        }
 
        public static event CollectionEventHandler CollectionCleared = null;
 
        public static Task<ILedgerEnumerator<T>> GetEnumerator<T>()
        {
            return Provider.GetEnumerator<T>();
        }
 
        public static Task<ILedgerEnumerator<object>> GetEnumerator(string CollectionName)
        {
            return Provider.GetEnumerator(CollectionName);
        }
 
        public static Task<string[]> GetCollections()
        {
            return Provider.GetCollections();
        }
 
        public static Task<bool> Export(ILedgerExport Output)
        {
            return Provider.Export(Output, null);
        }
 
        public static Task<bool> Export(ILedgerExport Output, LedgerExportRestriction Restriction)
        {
            return Provider.Export(Output, Restriction);
        }
 
        public static Task<bool> Export(ILedgerExport Output, LedgerExportRestriction Restriction, ProfilerThread Thread)
        {
            return Provider.Export(Output, Restriction, Thread);
        }
 
        private static readonly object listeningSynchObj = new object();
        private static int listeningCounter = 0;
 
        public static void StartListeningToDatabaseEvents()
        {
            lock (listeningSynchObj)
            {
                if (listeningCounter == 0)
                {
                    Database.ObjectInserted += Database_ObjectInserted;
                    Database.ObjectUpdated += Database_ObjectUpdated;
                    Database.ObjectDeleted += Database_ObjectDeleted;
                    Database.CollectionCleared += Database_CollectionCleared;
 
                    listeningCounter++;
                }
            }
 
        }
 
        public static void StopListeningToDatabaseEvents()
        {
            lock (listeningSynchObj)
            {
                if (listeningCounter > 0)
                {
                    listeningCounter--;
 
                    if (listeningCounter == 0)
                    {
                        Database.ObjectInserted -= Database_ObjectInserted;
                        Database.ObjectUpdated -= Database_ObjectUpdated;
                        Database.ObjectDeleted -= Database_ObjectDeleted;
                        Database.CollectionCleared -= Database_CollectionCleared;
                    }
                }
            }
        }
 
        private static async void Database_ObjectInserted(object Sender, ObjectEventArgs e)
        {
            try
            {
                GenericObject Obj = await Database.Generalize(e.Object);
                await NewEntry(Obj);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private static async void Database_ObjectUpdated(object Sender, ObjectEventArgs e)
        {
            try
            {
                GenericObject Obj = await Database.Generalize(e.Object);
                await UpdatedEntry(Obj);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private static async void Database_ObjectDeleted(object Sender, ObjectEventArgs e)
        {
            try
            {
                GenericObject Obj = await Database.Generalize(e.Object);
                await DeletedEntry(Obj);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private static async Task Database_CollectionCleared(object Sender, CollectionEventArgs e)
        {
            try
            {
                await ClearedCollection(e.Collection);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
    }
}