CachedStringDictionary.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Runtime.Cache;
 
namespace Waher.Persistence.NeuroLedger
{
    public class CachedStringDictionary : IDictionary<string, object>, IPersistentDictionary, IDisposable
    {
        private readonly Cache<string, Rec> cache;
        private readonly IPersistentDictionary dictionary;
 
        public CachedStringDictionary(int CacheSize, IPersistentDictionary Dictionary)
        {
            this.dictionary = Dictionary;
            this.cache = new Cache<string, Rec>(CacheSize, TimeSpan.MaxValue, TimeSpan.MaxValue, true);
            this.cache.Removed += this.Cache_Removed;
        }
 
        public class Rec
        {
            public object Value;
 
            public bool FromDB;
        }
 
        private async Task Cache_Removed(object Sender, CacheItemEventArgs<string, Rec> e)
        {
            try
            {
                switch (e.Reason)
                {
                    case RemovedReason.Replaced:
                        if (e.Value.FromDB)
                        {
                            try
                            {
                                await this.dictionary.RemoveAsync(e.Key);
                            }
                            catch (Exception ex)
                            {
                                Log.Exception(ex);
                            }
                        }
                        break;
 
                    case RemovedReason.NotUsed:
                    case RemovedReason.Old:
                    case RemovedReason.Space:
                        if (!e.Value.FromDB)
                        {
                            try
                            {
                                await this.dictionary.AddAsync(e.Key, e.Value.Value, true);
                            }
                            catch (Exception ex)
                            {
                                Log.Exception(ex);
                            }
                        }
                        break;
 
                    case RemovedReason.Manual:
                    default:
                        break;
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public object this[string key]
        {
            get
            {
                if (this.cache.TryGetValue(key, out Rec Rec))
                    return Rec.Value;
 
                if (this.dictionary.TryGetValue(key, out object Value))
                {
                    this.cache[key] = new Rec()
                    {
                        Value = Value,
                        FromDB = true
                    };
 
                    return Value;
                }
 
                throw new KeyNotFoundException("key not found in dictionary: " + key);
            }
 
            set
            {
                this.cache[key] = new Rec()
                {
                    Value = value,
                    FromDB = false
                };
            }
        }
 
        public ICollection<string> Keys
        {
            get
            {
                this.Flush();
                return this.dictionary.Keys;
            }
        }
 
        public ICollection<object> Values
        {
            get
            {
                this.Flush();
                return this.dictionary.Values;
            }
        }
 
        public int Count
        {
            get
            {
                this.Flush();
                return this.dictionary.Count;
            }
        }
 
        public bool IsReadOnly => false;
 
        public void Add(string key, object value)
        {
            this.cache[key] = new Rec()
            {
                Value = value,
                FromDB = false
            };
        }
 
        public void Add(KeyValuePair<string, object> item)
        {
            this.cache[item.Key] = new Rec()
            {
                Value = item.Value,
                FromDB = false
            };
        }
 
        public void Clear()
        {
            this.cache.Clear();
            this.dictionary.Clear();
        }
 
        public bool Contains(KeyValuePair<string, object> item)
        {
            if (this.cache.TryGetValue(item.Key, out Rec Rec))
                return Rec.Value.Equals(item.Value);
            else if (this.dictionary.TryGetValue(item.Key, out object Value))
                return Value.Equals(item.Value);
            else
                return false;
        }
 
        public bool ContainsKey(string key)
        {
            return this.cache.ContainsKey(key) || this.dictionary.ContainsKey(key);
        }
 
        public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
        {
            this.Flush();
            this.dictionary.CopyTo(array, arrayIndex);
        }
 
        public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
        {
            this.Flush();
            return this.dictionary.GetEnumerator();
        }
 
        public async Task<IEnumerator<KeyValuePair<string, object>>> GetEnumeratorAsync()
        {
            await this.FlushAsync();
            return this.dictionary.GetEnumerator();
        }
 
        public bool Remove(string key)
        {
            if (this.cache.TryGetValue(key, out Rec Rec))
            {
                this.cache.Remove(key);
 
                if (Rec.FromDB)
                    return this.dictionary.Remove(key);
                else
                    return true;
            }
            else
                return this.dictionary.Remove(key);
        }
 
        public bool Remove(KeyValuePair<string, object> item)
        {
            if (this.cache.TryGetValue(item.Key, out Rec Rec))
            {
                if (!Rec.Value.Equals(item.Value))
                    return false;
 
                this.cache.Remove(item.Key);
 
                if (Rec.FromDB)
                    return this.dictionary.Remove(item.Key);
                else
                    return true;
            }
            else if (this.dictionary.TryGetValue(item.Key, out object Value))
            {
                if (Value.Equals(item.Value))
                    return this.dictionary.Remove(item.Key);
                else
                {
                    this.cache[item.Key] = new Rec()
                    {
                        Value = Value,
                        FromDB = true
                    };
 
                    return false;
                }
            }
            else
                return false;
        }
 
        public bool TryGetValue(string key, out object value)
        {
            if (this.cache.TryGetValue(key, out Rec Rec))
            {
                value = Rec.Value;
                return true;
            }
            else if (this.dictionary.TryGetValue(key, out value))
            {
                this.cache[key] = new Rec()
                {
                    Value = value,
                    FromDB = true
                };
 
                return true;
            }
            else
                return false;
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            this.Flush();
            return this.dictionary.GetEnumerator();
        }
 
        public async void Flush()
        {
            try
            {
                KeyValuePair<string, Rec>[] Records = this.cache.ToArray();
                this.cache.Clear();
 
                try
                {
                    await Database.StartBulk();
 
                    int i = 0;
 
                    try
                    {
                        foreach (KeyValuePair<string, Rec> Rec in Records)
                        {
                            if (!Rec.Value.FromDB)
                            {
                                await this.dictionary.AddAsync(Rec.Key, Rec.Value.Value, true);
 
                                i++;
                                if (i >= 1000)
                                {
                                    await Database.EndBulk();
                                    await Database.StartBulk();
                                    i = 0;
                                }
                            }
                        }
                    }
                    finally
                    {
                        await Database.EndBulk();
                    }
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public async Task FlushAsync()
        {
            KeyValuePair<string, Rec>[] Records = this.cache.ToArray();
            this.cache.Clear();
 
            foreach (KeyValuePair<string, Rec> Rec in Records)
            {
                if (!Rec.Value.FromDB)
                    await this.dictionary.AddAsync(Rec.Key, Rec.Value.Value, true);
            }
        }
 
        public void Dispose()
        {
            this.Flush();
            this.cache.Dispose();
            this.dictionary.Dispose();
        }
 
        public void DeleteAndDispose()
        {
            this.Clear();
            this.dictionary.DeleteAndDispose();
        }
 
        public Task ClearAsync()
        {
            this.cache.Clear();
            return this.dictionary.ClearAsync();
        }
 
        public async Task<bool> ContainsKeyAsync(string key)
        {
            return this.cache.ContainsKey(key) || await this.dictionary.ContainsKeyAsync(key);
        }
 
        public Task AddAsync(string key, object value)
        {
            this.Add(key, value);
            return Task.CompletedTask;
        }
 
        public Task AddAsync(string key, object value, bool ReplaceIfExists)
        {
            if (ReplaceIfExists)
                this[key] = value;
            else
                this.Add(key, value);
 
            return Task.CompletedTask;
        }
 
        public async Task<bool> RemoveAsync(string key)
        {
            if (this.cache.TryGetValue(key, out Rec Rec))
            {
                this.cache.Remove(key);
 
                if (Rec.FromDB)
                    return await this.dictionary.RemoveAsync(key);
                else
                    return true;
            }
            else
                return await this.dictionary.RemoveAsync(key);
        }
 
        public async Task<KeyValuePair<bool, object>> TryGetValueAsync(string key)
        {
            if (this.cache.TryGetValue(key, out Rec Rec))
                return new KeyValuePair<bool, object>(true, Rec.Value);
            else
            {
                KeyValuePair<bool, object> P = await this.dictionary.TryGetValueAsync(key);
 
                if (P.Key)
                {
                    this.cache[key] = new Rec()
                    {
                        Value = P.Value,
                        FromDB = true
                    };
                }
 
                return P;
            }
        }
 
        public async Task<KeyValuePair<string, object>[]> GetEntriesAsync(string FromKey, string ToKey)
        {
            Dictionary<string, object> ByName = new Dictionary<string, object>();
 
            foreach (KeyValuePair<string, object> Entry in await this.dictionary.GetEntriesAsync(FromKey, ToKey))
                ByName[Entry.Key] = Entry.Value;
 
            foreach (KeyValuePair<string, Rec> Entry in this.cache.ToArray())
                ByName[Entry.Key] = Entry.Value;
 
            KeyValuePair<string, object>[] Result = new KeyValuePair<string, object>[ByName.Count];
            int i = 0;
            foreach (KeyValuePair<string, object> Entry in ByName)
                Result[i++] = Entry;
 
            return Result;
        }
 
        public Task CopyKeysToAsync(string[] Keys, int Offset)
        {
            return this.dictionary.CopyKeysToAsync(Keys, Offset);
        }
 
        public Task CopyValuesToAsync(object[] Values, int Offset)
        {
            return this.dictionary.CopyValuesToAsync(Values, Offset);
        }
 
        public Task<string[]> GetKeysAsync()
        {
            return this.dictionary.GetKeysAsync();
        }
 
        public Task<object[]> GetValuesAsync()
        {
            return this.dictionary.GetValuesAsync();
        }
 
    }
}