AssetCache.h

#pragma once
 
#include <xrpld/rpc/detail/MPT.h>
#include <xrpld/rpc/detail/TrustLine.h>
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/basics/UnorderedContainers.h>
#include <xrpl/basics/hardened_hash.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/AccountID.h>
 
#include <cstddef>
#include <memory>
#include <mutex>
#include <vector>
 
namespace xrpl {
 
// Used by Pathfinder
class AssetCache final : public CountedObject<AssetCache>
{
public:
    explicit AssetCache(std::shared_ptr<ReadView const> l, beast::Journal j);
    ~AssetCache();
 
    [[nodiscard]] std::shared_ptr<ReadView const> const&
    getLedger() const
    {
        return ledger_;
    }

    std::shared_ptr<std::vector<PathFindTrustLine>>
    getRippleLines(AccountID const& accountID, LineDirection direction);
 
    std::shared_ptr<std::vector<PathFindMPT>> const&
    getMPTs(AccountID const& account);
 
private:
    std::mutex lock_;
 
    xrpl::HardenedHash<> hasher_;
    std::shared_ptr<ReadView const> ledger_;
 
    beast::Journal journal_;
 
    struct AccountKey final : public CountedObject<AccountKey>
    {
        AccountID account;
        LineDirection direction;
        std::size_t hashValue;
 
        AccountKey(AccountID const& account, LineDirection direction, std::size_t hash)
            : account(account), direction(direction), hashValue(hash)
        {
        }
 
        AccountKey(AccountKey const& other) = default;
 
        AccountKey&
        operator=(AccountKey const& other) = default;
 
        bool
        operator==(AccountKey const& lhs) const
        {
            return hashValue == lhs.hashValue && account == lhs.account &&
                direction == lhs.direction;
        }
 
        [[nodiscard]] std::size_t
        getHash() const
        {
            return hashValue;
        }
 
        struct Hash
        {
            Hash() = default;
 
            std::size_t
            operator()(AccountKey const& key) const noexcept
            {
                return key.getHash();
            }
        };
    };
 
    // Use a shared_ptr so entries can be removed from the map safely.
    // Even though a shared_ptr to a vector will take more memory just a vector,
    // most accounts are not going to have any entries (estimated over 90%), so
    // vectors will not need to be created for them. This should lead to far
    // less memory usage overall.
    HashMap<AccountKey, std::shared_ptr<std::vector<PathFindTrustLine>>, AccountKey::Hash> lines_;
    std::size_t totalLineCount_ = 0;
    HashMap<AccountID, std::shared_ptr<std::vector<PathFindMPT>>> mpts_;
};
 
}  // namespace xrpl