FullBelowCache.h

#pragma once
 
#include <xrpl/basics/KeyCache.h>
#include <xrpl/basics/TaggedCache.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/insight/Collector.h>
#include <xrpl/beast/utility/Journal.h>
 
#include <atomic>
#include <string>
 
namespace xrpl {
 
namespace detail {
 
class BasicFullBelowCache
{
private:
    using CacheType = KeyCache;
 
public:
    enum { defaultCacheTargetSize = 0 };
 
    using key_type = uint256;
    using clock_type = typename CacheType::clock_type;
 
    BasicFullBelowCache(
        std::string const& name,
        clock_type& clock,
        beast::Journal j,
        beast::insight::Collector::ptr const& collector = beast::insight::NullCollector::New(),
        std::size_t target_size = defaultCacheTargetSize,
        std::chrono::seconds expiration = std::chrono::minutes{2})
        : m_cache(name, target_size, expiration, clock, j, collector), m_gen(1)
    {
    }
 
    clock_type&
    clock()
    {
        return m_cache.clock();
    }
 
    std::size_t
    size() const
    {
        return m_cache.size();
    }
 
    void
    sweep()
    {
        m_cache.sweep();
    }
 
    bool
    touch_if_exists(key_type const& key)
    {
        return m_cache.touch_if_exists(key);
    }
 
    void
    insert(key_type const& key)
    {
        m_cache.insert(key);
    }
 
    std::uint32_t
    getGeneration(void) const
    {
        return m_gen;
    }
 
    void
    clear()
    {
        m_cache.clear();
        ++m_gen;
    }
 
    void
    reset()
    {
        m_cache.clear();
        m_gen = 1;
    }
 
private:
    CacheType m_cache;
    std::atomic<std::uint32_t> m_gen;
};
 
}  // namespace detail
 
using FullBelowCache = detail::BasicFullBelowCache;
 
}  // namespace xrpl