RippleLineCache.h

#ifndef XRPL_APP_PATHS_RIPPLELINECACHE_H_INCLUDED
#define XRPL_APP_PATHS_RIPPLELINECACHE_H_INCLUDED
 
#include <xrpld/app/ledger/Ledger.h>
#include <xrpld/app/paths/TrustLine.h>
 
#include <xrpl/basics/CountedObject.h>
#include <xrpl/basics/hardened_hash.h>
 
#include <cstddef>
#include <mutex>
#include <vector>
 
namespace ripple {
 
// Used by Pathfinder
class RippleLineCache final : public CountedObject<RippleLineCache>
{
public:
    explicit RippleLineCache(
        std::shared_ptr<ReadView const> const& l,
        beast::Journal j);
    ~RippleLineCache();
 
    std::shared_ptr<ReadView const> const&
    getLedger() const
    {
        return ledger_;
    }
 
    std::shared_ptr<std::vector<PathFindTrustLine>>
    getRippleLines(AccountID const& accountID, LineDirection direction);
 
private:
    std::mutex mLock;
 
    ripple::hardened_hash<> hasher_;
    std::shared_ptr<ReadView const> ledger_;
 
    beast::Journal journal_;
 
    struct AccountKey final : public CountedObject<AccountKey>
    {
        AccountID account_;
        LineDirection direction_;
        std::size_t hash_value_;
 
        AccountKey(
            AccountID const& account,
            LineDirection direction,
            std::size_t hash)
            : account_(account), direction_(direction), hash_value_(hash)
        {
        }
 
        AccountKey(AccountKey const& other) = default;
 
        AccountKey&
        operator=(AccountKey const& other) = default;
 
        bool
        operator==(AccountKey const& lhs) const
        {
            return hash_value_ == lhs.hash_value_ && account_ == lhs.account_ &&
                direction_ == lhs.direction_;
        }
 
        std::size_t
        get_hash() const
        {
            return hash_value_;
        }
 
        struct Hash
        {
            Hash() = default;
 
            std::size_t
            operator()(AccountKey const& key) const noexcept
            {
                return key.get_hash();
            }
        };
    };
 
    // 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.
    hash_map<
        AccountKey,
        std::shared_ptr<std::vector<PathFindTrustLine>>,
        AccountKey::Hash>
        lines_;
    std::size_t totalLineCount_ = 0;
};
 
}  // namespace ripple
 
#endif