gitignore modefied

https://github.com/moneroexamples/onion-monero-blockchain-explorer/pull/45

ext/vpetrigocaches/cache.hpp

@@ -0,0 +1,138 @@
+#ifndef CACHE_HPP
+#define CACHE_HPP
+
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+#include "cache_policy.hpp"
+
+namespace caches
+{
+
+// Base class for caching algorithms
+template <typename Key, typename Value, typename Policy = NoCachePolicy<Key>>
+class fixed_sized_cache
+{
+ public:
+
+  using iterator = typename std::unordered_map<Key, Value>::iterator;
+
+  using const_iterator =
+      typename std::unordered_map<Key, Value>::const_iterator;
+
+  using operation_guard = typename std::lock_guard<std::mutex>;
+
+  fixed_sized_cache(
+          size_t max_size,
+          const Policy& policy = Policy())
+      : max_cache_size{max_size},
+        cache_policy(policy)
+  {
+    if (max_cache_size == 0)
+    {
+      max_cache_size = std::numeric_limits<size_t>::max();
+    }
+  }
+
+  void Put(const Key& key, const Value& value)
+  {
+    operation_guard{safe_op};
+    auto elem_it = FindElem(key);
+
+    if (elem_it == cache_items_map.end())
+    {
+      // add new element to the cache
+      if (Size() + 1 > max_cache_size)
+      {
+        auto disp_candidate_key = cache_policy.ReplCandidate();
+
+        Erase(disp_candidate_key);
+      }
+
+      Insert(key, value);
+    }
+    else
+    {
+      // update previous value
+      Update(key, value);
+    }
+  }
+
+  bool Contains(const Key& key)
+  {
+    operation_guard{safe_op};
+    auto elem_it = FindElem(key);
+    return elem_it != cache_items_map.end();
+  }
+
+  const Value& Get(const Key& key) const
+  {
+    operation_guard{safe_op};
+    auto elem_it = FindElem(key);
+
+    if (elem_it == cache_items_map.end())
+    {
+      throw std::range_error{"No such element in the cache"};
+    }
+    cache_policy.Touch(key);
+
+    return elem_it->second;
+  }
+
+  const size_t Size() const
+  {
+    operation_guard{safe_op};
+
+    return cache_items_map.size();
+  }
+
+  // return a key of a displacement candidate
+  void Clear()
+  {
+    operation_guard{safe_op};
+
+    cache_policy.Clear();
+    cache_items_map.clear();
+  }
+
+ protected:
+
+  void Insert(const Key& key, const Value& value)
+  {
+    cache_policy.Insert(key);
+    cache_items_map.emplace(std::make_pair(key, value));
+  }
+
+  void Erase(const Key& key)
+  {
+    cache_policy.Erase(key);
+    cache_items_map.erase(key);
+  }
+
+  void Update(const Key& key, const Value& value)
+  {
+    cache_policy.Touch(key);
+    cache_items_map[key] = value;
+  }
+
+  const_iterator FindElem(const Key& key) const
+  {
+    return cache_items_map.find(key);
+  }
+
+
+private:
+
+  std::unordered_map<Key, Value> cache_items_map;
+
+  mutable Policy cache_policy;
+  mutable std::mutex safe_op;
+
+  size_t max_cache_size;
+
+};
+}
+
+#endif  // CACHE_HPP

ext/vpetrigocaches/cache_policy.hpp

@@ -0,0 +1,77 @@
+#ifndef CACHE_POLICY_HPP
+#define CACHE_POLICY_HPP
+
+#include <unordered_set>
+
+namespace caches
+{
+
+template <typename Key>
+
+class ICachePolicy
+{
+ public:
+
+  virtual ~ICachePolicy() {}
+
+  // handle element insertion in a cache
+  virtual void Insert(const Key& key) = 0;
+
+  // handle request to the key-element in a cache
+  virtual void Touch(const Key& key) = 0;
+
+  // handle element deletion from a cache
+  virtual void Erase(const Key& key) = 0;
+
+  // return a key of a replacement candidate
+  virtual const Key& ReplCandidate() const = 0;
+
+  // clear the cache
+  virtual void Clear() = 0;
+
+};
+
+template <typename Key>
+class NoCachePolicy : public ICachePolicy<Key>
+{
+ public:
+
+  NoCachePolicy() = default;
+
+  ~NoCachePolicy() override = default;
+
+  void Insert(const Key& key) override
+  {
+    key_storage.emplace(key);
+  }
+
+  void Touch(const Key& key) override
+  {
+    // do not do anything
+  }
+
+  void Erase(const Key& key) override
+  {
+    key_storage.erase(key);
+  }
+
+  // return a key of a displacement candidate
+  const Key& ReplCandidate() const override
+  {
+    return *key_storage.crbegin();
+  }
+
+  // return a key of a displacement candidate
+  void Clear() override
+  {
+    key_storage.clear();
+  }
+
+ private:
+
+  std::unordered_set<Key> key_storage;
+};
+
+}  // namespace caches
+
+#endif  // CACHE_POLICY_HPP

ext/vpetrigocaches/fifo_cache_policy.hpp

@@ -0,0 +1,53 @@
+#ifndef FIFO_CACHE_POLICY_HPP
+#define FIFO_CACHE_POLICY_HPP
+
+#include <list>
+#include "cache_policy.hpp"
+
+namespace caches
+{
+
+template <typename Key>
+class FIFOCachePolicy : public ICachePolicy<Key>
+{
+ public:
+
+  FIFOCachePolicy() = default;
+  ~FIFOCachePolicy() = default;
+
+  void Insert(const Key& key) override
+  {
+    fifo_queue.emplace_front(key);
+  }
+
+  // handle request to the key-element in a cache
+  void Touch(const Key& key) override
+  {
+    // nothing to do here in the FIFO strategy
+  }
+
+  // handle element deletion from a cache
+  void Erase(const Key& key) override
+  {
+    fifo_queue.pop_back();
+  }
+
+  // return a key of a replacement candidate
+  const Key& ReplCandidate() const override
+  {
+    return fifo_queue.back();
+  }
+
+  // return a key of a displacement candidate
+  void Clear() override
+  {
+    fifo_queue.clear();
+  }
+
+private:
+
+  std::list<Key> fifo_queue;
+};
+} // namespace caches
+
+#endif // FIFO_CACHE_POLICY_HPP

ext/vpetrigocaches/lfu_cache_policy.hpp

@@ -0,0 +1,76 @@
+#ifndef LFU_CACHE_POLICY_HPP
+#define LFU_CACHE_POLICY_HPP
+
+#include <cstddef>
+#include <unordered_map>
+#include <map>
+#include <iostream>
+#include "cache_policy.hpp"
+
+namespace caches
+{
+template <typename Key>
+class LFUCachePolicy : public ICachePolicy<Key>
+{
+ public:
+
+  using lfu_iterator = typename std::multimap<std::size_t, Key>::iterator;
+
+  LFUCachePolicy() = default;
+
+  ~LFUCachePolicy() override = default;
+
+  void Insert(const Key& key) override
+  {
+    constexpr std::size_t INIT_VAL = 1;
+
+    // all new value initialized with the frequency 1
+    lfu_storage[key] = frequency_storage.emplace_hint(
+            frequency_storage.cbegin(), INIT_VAL, key);
+  }
+
+  void Touch(const Key& key) override
+  {
+    // get the previous frequency value of a key
+    auto elem_for_update = lfu_storage[key];
+
+    auto updated_elem = std::make_pair(
+            elem_for_update->first + 1, elem_for_update->second);
+
+    // update the previous value
+    frequency_storage.erase(elem_for_update);
+
+    lfu_storage[key] = frequency_storage.emplace_hint(
+            frequency_storage.cend(), std::move(updated_elem));
+  }
+
+  void Erase(const Key& key) override
+  {
+    frequency_storage.erase(lfu_storage[key]);
+    lfu_storage.erase(key);
+  }
+
+  const Key& ReplCandidate() const override
+  {
+    // at the beginning of the frequency_storage we have the
+    // least frequency used value
+    return frequency_storage.cbegin()->second;
+  }
+
+  // return a key of a displacement candidate
+  void Clear() override
+  {
+    frequency_storage.clear();
+    lfu_storage.clear();
+  }
+
+
+ private:
+
+  std::multimap<std::size_t, Key> frequency_storage;
+
+  std::unordered_map<Key, lfu_iterator> lfu_storage;
+};
+} // namespace caches
+
+#endif // LFU_CACHE_POLICY_HPP

ext/vpetrigocaches/lru_cache_policy.hpp

@@ -0,0 +1,63 @@
+#ifndef LRU_CACHE_POLICY_HPP
+#define LRU_CACHE_POLICY_HPP
+
+#include <list>
+#include <unordered_map>
+#include "cache_policy.hpp"
+
+namespace caches
+{
+template <typename Key>
+class LRUCachePolicy : public ICachePolicy<Key>
+{
+
+ public:
+
+  using lru_iterator = typename std::list<Key>::const_iterator;
+  
+  LRUCachePolicy() = default;
+  ~LRUCachePolicy() = default;
+  
+  void Insert(const Key& key) override
+  {
+    lru_queue.emplace_front(key);
+    key_finder[key] = lru_queue.cbegin();
+  }
+  
+  void Touch(const Key& key) override
+  {
+    // move the touched element at the beginning of the lru_queue 
+    lru_queue.splice(lru_queue.cbegin(), lru_queue, key_finder[key]);
+  }
+  
+  void Erase(const Key& key) override
+  {
+    // remove the least recently used element
+    key_finder.erase(lru_queue.back());
+
+    lru_queue.pop_back();
+  }
+
+  // return a key of a displacement candidate
+  const Key& ReplCandidate() const override
+  {
+    return lru_queue.back();
+  }
+
+  // return a key of a displacement candidate
+  void Clear() override
+  {
+      lru_queue.clear();
+      key_finder.clear();
+  }
+  
+ private:
+
+  std::list<Key> lru_queue;
+
+  std::unordered_map<Key, lru_iterator> key_finder; 
+};
+
+} // namespace caches
+
+#endif // LRU_CACHE_POLICY_HPP