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:
    static constexpr auto kDefaultCacheTargetSize = 0;
 
    using key_type = uint256;
    using clock_type = CacheType::clock_type;

    BasicFullBelowCache(
        std::string const& name,
        clock_type& clock,
        beast::Journal j,
        beast::insight::Collector::ptr const& collector = beast::insight::NullCollector::make(),
        std::size_t targetSize = kDefaultCacheTargetSize,
        std::chrono::seconds expiration = std::chrono::minutes{2})
        : cache_(name, targetSize, expiration, clock, j, collector), gen_(1)
    {
    }

    clock_type&
    clock()
    {
        return cache_.clock();
    }

    std::size_t
    size() const
    {
        return cache_.size();
    }

    void
    sweep()
    {
        cache_.sweep();
    }

    bool
    touchIfExists(key_type const& key)
    {
        return cache_.touchIfExists(key);
    }

    void
    insert(key_type const& key)
    {
        cache_.insert(key);
    }

    std::uint32_t
    getGeneration(void) const
    {
        return gen_;
    }
 
    void
    clear()
    {
        cache_.clear();
        ++gen_;
    }
 
    void
    reset()
    {
        cache_.clear();
        gen_ = 1;
    }
 
private:
    CacheType cache_;
    std::atomic<std::uint32_t> gen_;
};
 
}  // namespace detail
 
using FullBelowCache = detail::BasicFullBelowCache;
 
}  // namespace xrpl