Bootcache.h

#pragma once
 
#include <xrpl/beast/net/IPEndpoint.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/beast/utility/PropertyStream.h>
#include <xrpl/peerfinder/Types.h>
#include <xrpl/peerfinder/detail/Store.h>
#include <xrpl/peerfinder/detail/Tuning.h>
 
#include <boost/bimap.hpp>
#include <boost/bimap/multiset_of.hpp>
#include <boost/bimap/unordered_set_of.hpp>
#include <boost/iterator/transform_iterator.hpp>
 
#include <functional>
 
namespace xrpl::peer_finder {

class Bootcache
{
private:
    class Entry
    {
    public:
        Entry(int valence) : valence_(valence)
        {
        }
 
        int&
        valence()
        {
            return valence_;
        }
 
        [[nodiscard]] int
        valence() const
        {
            return valence_;
        }
 
        friend bool
        operator<(Entry const& lhs, Entry const& rhs)
        {
            return lhs.valence() > rhs.valence();
        }
 
    private:
        int valence_;
    };
 
    using LeftT = boost::bimaps::
        unordered_set_of<beast::ip::Endpoint, boost::hash<beast::ip::Endpoint>, std::equal_to<>>;
    using RightT = boost::bimaps::multiset_of<Entry, std::less<>>;
    using MapType = boost::bimap<LeftT, RightT>;
    using value_type = MapType::value_type;
 
    struct Transform
    {
        using first_argument_type = MapType::right_map::const_iterator::value_type const&;
        using result_type = beast::ip::Endpoint const&;
 
        explicit Transform() = default;
 
        beast::ip::Endpoint const&
        operator()(MapType::right_map::const_iterator::value_type const& v) const
        {
            return v.get_left();
        }
    };
 
private:
    MapType map_;
 
    Store& store_;
    ClockType& clock_;
    beast::Journal journal_;
 
    // Time after which we can update the database again
    ClockType::time_point whenUpdate_;
 
    // Set to true when a database update is needed
    bool needsUpdate_{false};
 
public:
    static constexpr int kStaticValence = 32;
 
    using iterator = boost::transform_iterator<Transform, MapType::right_map::const_iterator>;
 
    using const_iterator = iterator;
 
    Bootcache(Store& store, ClockType& clock, beast::Journal journal);
 
    ~Bootcache();

    [[nodiscard]] bool
    empty() const;

    [[nodiscard]] MapType::size_type
    size() const;

    [[nodiscard]] const_iterator
    begin() const;
    [[nodiscard]] const_iterator
    cbegin() const;
    [[nodiscard]] const_iterator
    end() const;
    [[nodiscard]] const_iterator
    cend() const;
    void
    clear();

    void
    load();

    bool
    insert(beast::ip::Endpoint const& endpoint);

    bool
    insertStatic(beast::ip::Endpoint const& endpoint);

    void
    onSuccess(beast::ip::Endpoint const& endpoint);

    void
    onFailure(beast::ip::Endpoint const& endpoint);

    void
    periodicActivity();

    void
    onWrite(beast::PropertyStream::Map& map);
 
private:
    void
    prune();
    void
    update();
    void
    checkUpdate();
    void
    flagForUpdate();
};
 
}  // namespace xrpl::peer_finder