CachedView.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/hardened_hash.h>
#include <xrpl/ledger/CachedSLEs.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/Fees.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/LedgerHeader.h>
#include <xrpl/protocol/Rules.h>
#include <xrpl/protocol/STLedgerEntry.h>
 
#include <memory>
#include <mutex>
#include <optional>
#include <type_traits>
#include <unordered_map>
 
namespace xrpl {
 
namespace detail {
 
class CachedViewImpl : public DigestAwareReadView
{
private:
    DigestAwareReadView const& base_;
    CachedSLEs& cache_;
    std::mutex mutable mutex_;
    std::unordered_map<key_type, uint256, HardenedHash<>> mutable map_;
 
public:
    CachedViewImpl() = delete;
    CachedViewImpl(CachedViewImpl const&) = delete;
    CachedViewImpl&
    operator=(CachedViewImpl const&) = delete;
 
    CachedViewImpl(DigestAwareReadView const* base, CachedSLEs& cache) : base_(*base), cache_(cache)
    {
    }
 
    //
    // ReadView
    //
 
    bool
    exists(Keylet const& k) const override;
 
    SLE::const_pointer
    read(Keylet const& k) const override;
 
    bool
    open() const override
    {
        return base_.open();
    }
 
    LedgerHeader const&
    header() const override
    {
        return base_.header();
    }
 
    Fees const&
    fees() const override
    {
        return base_.fees();
    }
 
    Rules const&
    rules() const override
    {
        return base_.rules();
    }
 
    std::optional<key_type>
    succ(key_type const& key, std::optional<key_type> const& last = std::nullopt) const override
    {
        return base_.succ(key, last);
    }
 
    std::unique_ptr<SlesType::iter_base>
    slesBegin() const override
    {
        return base_.slesBegin();
    }
 
    std::unique_ptr<SlesType::iter_base>
    slesEnd() const override
    {
        return base_.slesEnd();
    }
 
    std::unique_ptr<SlesType::iter_base>
    slesUpperBound(uint256 const& key) const override
    {
        return base_.slesUpperBound(key);
    }
 
    std::unique_ptr<TxsType::iter_base>
    txsBegin() const override
    {
        return base_.txsBegin();
    }
 
    std::unique_ptr<TxsType::iter_base>
    txsEnd() const override
    {
        return base_.txsEnd();
    }
 
    bool
    txExists(key_type const& key) const override
    {
        return base_.txExists(key);
    }
 
    tx_type
    txRead(key_type const& key) const override
    {
        return base_.txRead(key);
    }
 
    //
    // DigestAwareReadView
    //
 
    std::optional<digest_type>
    digest(key_type const& key) const override
    {
        return base_.digest(key);
    }
};
 
}  // namespace detail

template <class Base>
class CachedView : public detail::CachedViewImpl
{
private:
    static_assert(std::is_base_of_v<DigestAwareReadView, Base>);
 
    std::shared_ptr<Base const> sp_;
 
public:
    using base_type = Base;
 
    CachedView() = delete;
    CachedView(CachedView const&) = delete;
    CachedView&
    operator=(CachedView const&) = delete;
 
    CachedView(std::shared_ptr<Base const> const& base, CachedSLEs& cache)
        : CachedViewImpl(base.get(), cache), sp_(base)
    {
    }

    std::shared_ptr<Base const> const&
    base() const
    {
        return sp_;
    }
};
 
}  // namespace xrpl