abstract_cache.hpp

Go to the documentation of this file.

#ifndef IROHA_ABSTRACT_CACHE_HPP
#define IROHA_ABSTRACT_CACHE_HPP

#include <boost/optional.hpp>
#include <list>
#include <shared_mutex>
#include <string>

namespace iroha {
  namespace cache {
    template <typename KeyType, typename ValueType, typename T>
    class AbstractCache {
     public:
      uint32_t getIndexSizeHigh() const {
        // shared lock
        std::shared_lock<std::shared_timed_mutex> lock(access_mutex_);
        return constUnderlying().getIndexSizeHighImpl();
      }

      uint32_t getCacheItemCount() const {
        // shared lock
        std::shared_lock<std::shared_timed_mutex> lock(access_mutex_);
        return constUnderlying().getCacheItemCountImpl();
      }

      void addItem(const KeyType &key, const ValueType &value) {
        // exclusive lock
        std::lock_guard<std::shared_timed_mutex> lock(access_mutex_);
        underlying().addItemImpl(key, value);
      }

      boost::optional<ValueType> findItem(const KeyType &key) const {
        std::shared_lock<std::shared_timed_mutex> lock(access_mutex_);
        return constUnderlying().findItemImpl(key);
      }

     private:
      const T &constUnderlying() const {
        return static_cast<const T &>(*this);
      }
      T &underlying() {
        return static_cast<T &>(*this);
      }

      mutable std::shared_timed_mutex access_mutex_;
    };
  }  // namespace cache
}  // namespace iroha

#endif  // IROHA_ABSTRACT_CACHE_HPP